using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Threading;

namespace Dreamteck.Splines
{
    [RequireComponent(typeof(MeshFilter))]
    [RequireComponent(typeof(MeshRenderer))]
    [AddComponentMenu("Dreamteck/Splines/Users/Spline Mesh")]
    public partial class SplineMesh : MeshGenerator
    {
        //Mesh data
        [SerializeField]
        [HideInInspector, UnityEngine.Serialization.FormerlySerializedAs("channels")]
        private List<Channel> _channels = new List<Channel>();
        private bool _useLastResult = false;
        private List<TS_Mesh> _combineMeshes = new List<TS_Mesh>();

        protected override string meshName => "Custom Mesh";

        private Matrix4x4 _vertexMatrix = new Matrix4x4();
        private Matrix4x4 _normalMatrix = new Matrix4x4();
        private SplineSample _lastResult = new SplineSample(), _modifiedResult = new SplineSample();

        protected override void Awake()
        {
            base.Awake();
#if UNITY_EDITOR
            for (int i = 0; i < _channels.Count; i++)
            {
                for (int j = 0; j < _channels[i].GetMeshCount(); j++)
                {
                    _channels[i].GetMesh(j).Refresh();
                }
            }
#endif
        }

        protected override void Reset()
        {
            base.Reset();
            AddChannel("Channel 1");
        }

        public void RemoveChannel(int index)
        {
            _channels.RemoveAt(index);
            Rebuild();
        }

        public void SwapChannels(int a, int b)
        {
            if (a < 0 || a >= _channels.Count || b < 0 || b >= _channels.Count) return;
            Channel temp = _channels[b];
            _channels[b] = _channels[a];
            _channels[a] = temp;
            Rebuild();
        }

        public Channel AddChannel(Mesh inputMesh, string name)
        {
            Channel channel = new Channel(name, inputMesh, this);
            _channels.Add(channel);
            return channel;
        }

        public Channel AddChannel(string name)
        {
            Channel channel = new Channel(name, this);
            _channels.Add(channel);
            return channel;
        }

        public int GetChannelCount()
        {
            return _channels.Count;
        }

        public Channel GetChannel(int index)
        {
            return _channels[index];
        }


        protected override void BuildMesh()
        {
            base.BuildMesh();
            Generate();
        }

        private void Generate()
        {
            int meshCount = 0;
            for (int i = 0; i < _channels.Count; i++)
            {
                if (_channels[i].GetMeshCount() == 0) continue;

                if (_channels[i].autoCount)
                {
                    float avgBounds = 0f;
                    for (int j = 0; j < _channels[i].GetMeshCount(); j++)
                    {
                        avgBounds += _channels[i].GetMesh(j).bounds.size.z;
                    }

                    if (_channels[i].GetMeshCount() > 1)
                    {
                        avgBounds /= _channels[i].GetMeshCount();
                    }

                    if (avgBounds > 0f)
                    {
                        float length = CalculateLength(_channels[i].clipFrom, _channels[i].clipTo);
                        int newCount = Mathf.RoundToInt(length / avgBounds);
                        if (newCount < 1)
                        {
                            newCount = 1;
                        }
                        _channels[i].count = newCount;
                    }
                }

                meshCount += _channels[i].count;
            }

            if(meshCount == 0)
            {
                _tsMesh.Clear();
                return;
            }

            if (_combineMeshes.Count < meshCount)
            {
                _combineMeshes.AddRange(new TS_Mesh[meshCount - _combineMeshes.Count]);
            }
            else if (_combineMeshes.Count > meshCount)
            {
                _combineMeshes.RemoveRange((_combineMeshes.Count - 1) - (_combineMeshes.Count - meshCount), _combineMeshes.Count - meshCount);
            }

            int combineMeshIndex = 0;
            for (int i = 0; i < _channels.Count; i++)
            {
                if (_channels[i].GetMeshCount() == 0) continue;
                _channels[i].ResetIteration();
                _useLastResult = false;
                double step = 1.0 / _channels[i].count;
                double space = step * _channels[i].spacing * 0.5;
                
                switch (_channels[i].type)
                {
                    case Channel.Type.Extrude:
                        for (int j = 0; j < _channels[i].count; j++)
                        {
                            double from = DMath.Lerp(_channels[i].clipFrom, _channels[i].clipTo, j * step + space);
                            double to = DMath.Lerp(_channels[i].clipFrom, _channels[i].clipTo, j * step + step - space);
                            if (_combineMeshes[combineMeshIndex] == null)
                            {
                                _combineMeshes[combineMeshIndex] = new TS_Mesh();
                            }
                            Extrude(_channels[i], _combineMeshes[combineMeshIndex], from, to);
                            combineMeshIndex++;
                        }
                        if (space == 0f) _useLastResult = true;
                        break;
                    case Channel.Type.Place:
                        for (int j = 0; j < _channels[i].count; j++)
                        {
                            if (_combineMeshes[combineMeshIndex] == null)
                            {
                                _combineMeshes[combineMeshIndex] = new TS_Mesh();
                            }
                            Place(_channels[i], _combineMeshes[combineMeshIndex], DMath.Lerp(_channels[i].clipFrom, _channels[i].clipTo, (double)j / Mathf.Max(_channels[i].count - 1, 1)));
                            combineMeshIndex++;
                        }
                        break;
                   
                }
            }
            _tsMesh.Combine(_combineMeshes);
        }

        private void Place(Channel channel, TS_Mesh target, double percent)
        {
            Channel.MeshDefinition definition = channel.NextMesh();
            if (target == null) target = new TS_Mesh();
            definition.Write(target, channel.overrideMaterialID ? channel.targetMaterialID : -1);
            Vector2 channelOffset = channel.NextRandomOffset();
            Quaternion channelRotation = channel.NextRandomQuaternion();

            var customValues = channel.GetCustomPlaceValues(percent);

            Vector2 finalOffset = channelOffset + customValues.Item1 + new Vector2(offset.x, offset.y);
            Quaternion finalRotation = channelRotation * Quaternion.AngleAxis(rotation, Vector3.forward) * customValues.Item2;
            Vector3 finalScale = channel.NextPlaceScale();

            Evaluate(percent, ref evalResult);
            ModifySample(ref evalResult);
            Vector3 originalNormal = evalResult.up;
            Vector3 originalRight = evalResult.right;
            Vector3 originalDirection = evalResult.forward;
            if (channel.overrideNormal)
            {
                evalResult.forward = Vector3.Cross(evalResult.right, channel.customNormal);
                evalResult.up = channel.customNormal;
            }

            if (!channel.scaleModifier.useClippedPercent)
            {
                UnclipPercent(ref evalResult.percent);
            }
            Vector3 scaleMod = channel.scaleModifier.GetScale(evalResult);
            finalScale.x *= customValues.Item3.x * scaleMod.x;
            finalScale.y *= customValues.Item3.y * scaleMod.y;
            finalScale.z *= customValues.Item3.z * scaleMod.z;

            if (!channel.scaleModifier.useClippedPercent)
            {
                ClipPercent(ref evalResult.percent);
            }

            float resultSize = GetBaseSize(evalResult);
            _vertexMatrix.SetTRS(evalResult.position + originalRight * (finalOffset.x * resultSize) + originalNormal * (finalOffset.y * resultSize) + originalDirection * offset.z, //Position
                evalResult.rotation * finalRotation, //Rotation
                finalScale * resultSize ); //Scale
            _normalMatrix = _vertexMatrix.inverse.transpose;

            for (int i = 0; i < target.vertexCount; i++)
            {
                target.vertices[i] = _vertexMatrix.MultiplyPoint3x4(definition.vertices[i]);
                target.normals[i] = _normalMatrix.MultiplyVector(definition.normals[i]);
            }
            for (int i = 0; i < Mathf.Min(target.colors.Length, definition.colors.Length); i++)
            {
                target.colors[i] = definition.colors[i] * evalResult.color * color;
            }
        }

        private void Extrude(Channel channel, TS_Mesh target, double from, double to)
        {
            Channel.MeshDefinition definition = channel.NextMesh();
            if (target == null) target = new TS_Mesh();
            definition.Write(target, channel.overrideMaterialID ? channel.targetMaterialID : -1);
            Vector2 uv = Vector2.zero;
            Vector3 trsVector = Vector3.zero;

            Vector3 channelOffset = channel.NextRandomOffset();
            Vector3 channelScale = channel.NextRandomScale();
            float channelRotation = channel.NextRandomAngle();

            for (int i = 0; i < definition.vertexGroups.Count; i++)
            {
                if (_useLastResult && i == definition.vertexGroups.Count)
                {
                    evalResult = _lastResult;
                }
                else
                {
                    Evaluate(DMath.Lerp(from, to, definition.vertexGroups[i].percent), ref evalResult);
                }
                ModifySample(ref evalResult, ref _modifiedResult);
                Vector3 originalNormal = _modifiedResult.up;
                Vector3 originalRight = _modifiedResult.right;
                Vector3 originalDirection = _modifiedResult.forward;
                if (channel.overrideNormal)
                {
                    _modifiedResult.forward = Vector3.Cross(_modifiedResult.right, channel.customNormal);
                    _modifiedResult.up = channel.customNormal;
                }
                var customValues = channel.GetCustomExtrudeValues(_modifiedResult.percent);
                Vector3 finalOffset = offset + channelOffset + (Vector3)customValues.Item1;
                float finalRotation = rotation + channelRotation + customValues.Item2;
                Vector3 finalScale = channelScale;
                if (!channel.scaleModifier.useClippedPercent)
                {
                    UnclipPercent(ref _modifiedResult.percent);
                }
                Vector2 scaleMod = channel.scaleModifier.GetScale(_modifiedResult);
                if (!channel.scaleModifier.useClippedPercent)
                {
                    ClipPercent(ref _modifiedResult.percent);
                }
                finalScale.x *= customValues.Item3.x * scaleMod.x;
                finalScale.y *= customValues.Item3.y * scaleMod.y;
                finalScale.z = 1f;
                float resultSize = _modifiedResult.size;
                _vertexMatrix.SetTRS(_modifiedResult.position + originalRight * (finalOffset.x * resultSize) + originalNormal * (finalOffset.y * resultSize) + originalDirection * offset.z, //Position
                    _modifiedResult.rotation * Quaternion.AngleAxis(finalRotation, Vector3.forward), //Rotation
                    finalScale * resultSize); //Scale
                _normalMatrix = _vertexMatrix.inverse.transpose;
                if (i == 0)
                {
                    _lastResult = evalResult;
                }

                for (int n = 0; n < definition.vertexGroups[i].ids.Length; n++)
                {
                    int index = definition.vertexGroups[i].ids[n];
                    trsVector = definition.vertices[index];
                    trsVector.z = 0f;
                    target.vertices[index] = _vertexMatrix.MultiplyPoint3x4(trsVector);
                    trsVector = definition.normals[index];
                    target.normals[index] = _normalMatrix.MultiplyVector(trsVector);
                    target.colors[index] = target.colors[index] * _modifiedResult.color * color;
                    if (target.uv.Length > index)
                    {
                        uv = target.uv[index];
                        switch (channel.overrideUVs)
                        {
                            case Channel.UVOverride.ClampU: uv.x = (float)_modifiedResult.percent; break;
                            case Channel.UVOverride.ClampV: uv.y = (float)_modifiedResult.percent; break;
                            case Channel.UVOverride.UniformU: uv.x = CalculateLength(0.0, ClipPercent(_modifiedResult.percent)); break;
                            case Channel.UVOverride.UniformV: uv.y = CalculateLength(0.0, ClipPercent(_modifiedResult.percent)); break;
                        }
                        target.uv[index] = new Vector2(uv.x * uvScale.x * channel.uvScale.x, uv.y * uvScale.y * channel.uvScale.y);
                        target.uv[index] += uvOffset + channel.uvOffset;
                    }
                }
            }
        }
    }
}