using System;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using PathUtils = UnityEngine.Gonbest.MagicCube.PathUtils;
using CoroutinePool = UnityEngine.Gonbest.MagicCube.CoroutinePool;
using StringUtils = UnityEngine.Gonbest.MagicCube.StringUtils;
using FFileReader = UnityEngine.Gonbest.MagicCube.FFileReader;

namespace Thousandto.Cinematic
{
    [Serializable]
    public abstract class ICinematic
    {
        [NonSerialized]
        private Stream _fStream;
        [NonSerialized]
        private BinaryWriter _bWriter;
        [NonSerialized]
        private BinaryReader _bReader;

        protected static string _rootPath;
        protected static string _extension = ".bytes";

        public Dictionary<string, object> Serialize()
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            var fields = GetType().GetFields();
            for (int i = 0; i < fields.Length; ++i)
            {
                if (fields[i].Name == "" || fields[i].Name == "") continue;
                var value = fields[i].GetValue(this);

                if (Attribute.IsDefined(fields[i], typeof(NonSerializedAttribute))) continue;

                if (value is List<CinematicObj> && value != null)
                {
                    value = ToObj((List<CinematicObj>)value);
                }
                if (value is List<CinematicKeyframe> && value != null)
                {
                    value = ToObj((List<CinematicKeyframe>)value);
                }
                if (value is List<CinematicEventData> && value != null)
                {
                    value = ToObj((List<CinematicEventData>)value);
                }
                if (value is CinematicEventData && value != null)
                {
                    value = ((CinematicEventData)value).Serialize();
                }
                if (value is CinematicKeyframe && value != null)
                {
                    value = ((CinematicKeyframe)value).Serialize();
                }
                if (value is KeyFrameEvent)
                {
                    dict.Add(fields[i].Name, (int)value);
                }
                else
                {
                    if (value != null)
                        dict.Add(fields[i].Name, value);
                }
            }

            return dict;
        }

        public virtual object Deserialize(object dictObj)
        {
            Dictionary<string, object> dict = dictObj as Dictionary<string, object>;
            if (dict == null) return null;

            var fields = GetType().GetFields();
            for (int i = 0; i < fields.Length; ++i)
            {
                var type = fields[i].FieldType;
                object value;
                if (dict.TryGetValue(fields[i].Name, out value))
                {
                    if (type == typeof(List<CinematicObj>) && value != null)
                    {
                        value = ToClass<CinematicObj>(value);
                    }
                    if (type == typeof(List<CinematicKeyframe>) && value != null)
                    {
                        value = ToClass<CinematicKeyframe>(value);
                    }
                    else if (type == typeof(List<CinematicEventData>))
                    {
                        value = ToClass<CinematicEventData>(value);
                    }
                    else if (type == typeof(CinematicEventData) && value != null)
                    {
                        value = new CinematicEventData().Deserialize(value);
                    }
                    else if (type == typeof(CinematicKeyframe) && value != null)
                    {
                        value = new CinematicKeyframe().Deserialize(value);
                    }

                    fields[i].SetValue(this, value);
                }
            }

            return this;
        }

        public object ToObj<T>(List<T> listData) where T : ICinematic
        {
            List<Dictionary<string, object>> ret = new List<Dictionary<string, object>>();
            for (int i = 0; i < listData.Count; ++i)
            {
                Dictionary<string, object> value = null;
                if (listData[i] is T && listData[i] != null)
                {
                    value = ((T)listData[i]).Serialize();
                }
                else
                    value = null;

                ret.Add(value);
            }

            return ret;
        }

        public List<T> ToClass<T>(object listDataObj) where T : ICinematic
        {
            var listData = listDataObj as List<Dictionary<string, object>>;
            List<T> ret = new List<T>();
            for (int i = 0; i < listData.Count; ++i)
            {
                object value = null;
                if (listData[i] != null)
                {
                    var ins1 = typeof(T).Assembly.CreateInstance(typeof(T).FullName);
                    var ins2 = typeof(T).Assembly.CreateInstance(typeof(T).FullName, true);
                    if (ins1 == null) ins1 = ins2;
                    var instance = ins1 as T;
                    value = instance.Deserialize(listData[i]);
                }
                else
                    value = listData[i];

                ret.Add((T)value);
            }

            return ret;
        }

        public virtual ICinematic newInstance() { return null; }
        public virtual void WriteAll(BinaryWriter bw) { }
        public virtual void ReadAll(BinaryReader rd) { }

        static ICinematic() { InitRootPath(); }

        public static string InitRootPath()
        {
            _rootPath = PathUtils.GetStreamingRootPath("/Cinematics");
            if (!Directory.Exists(_rootPath))
                Directory.CreateDirectory(_rootPath);
            return _rootPath;
        }

        public static string GetExtension()
        {
            return _extension;
        }

        public string GetFullPath(string clipName)
        {
            return _rootPath + "/" + clipName + _extension;
        }

        public void PrepareWrite(string clipName)
        {
            if (_bWriter != null) _bWriter.Close();
            if (_fStream != null) _fStream.Close();

            _fStream = new FileStream(GetFullPath(clipName), FileMode.Create);
            _bWriter = new BinaryWriter(_fStream);
        }

        public void EndWrite()
        {
            if (_bWriter != null) _bWriter.Close();
            if (_fStream != null) _fStream.Close();
        }

        public void PrepareWriter(BinaryWriter bw)
        {
            _bWriter = bw;
        }

        public void PrepareReader(BinaryReader br)
        {
            _bReader = br;
        }

        public void PrepareRead(string clipName)
        {
            if (_bReader != null) _bReader.Close();
            if (_fStream != null) _fStream.Close();

            UnityEngine.Debug.Log("Load cinematic file: " + clipName);
            //if (!File.Exists(GetFullPath(clipName)))
            //    _rootPath = Application.streamingAssetsPath + "/Cinematics";

            //string fullPath = GetFullPath(clipName);
            //_fStream = new FileStream(fullPath, FileMode.Open, FileAccess.Read);

            FFileReader.ReadBytesAsync(GetFullPath(clipName),x=> {
                _fStream = new MemoryStream(x);
                _bReader = new BinaryReader(_fStream);
            });
            
        }

        public void EndRead()
        {
            if (_bReader != null) _bReader.Close();
            if (_fStream != null) _fStream.Close();
        }

        public void WriteInt(int value)
        {
            _bWriter.Write(value);
        }

        public int ReadInt()
        {
            return _bReader.ReadInt32();
        }

        public void WriteFloat(float value)
        {
            _bWriter.Write(value);
        }

        public float ReadFloat()
        {
            return _bReader.ReadSingle();
        }

        public void WriteString(string value)
        {
            _bWriter.Write(value);
        }

        public string ReadString()
        {
            return _bReader.ReadString();
        }

        public void WriteBool(bool value)
        {
            _bWriter.Write(value);
        }

        public bool ReadBool()
        {
            return _bReader.ReadBoolean();
        }

        public void WriteVector3(float[] vale)
        {
            for (int i = 0; i < vale.Length; ++i)
            {
                WriteFloat(vale[i]);
            }
        }

        public float[] ReadVector3()
        {
            float[] ret = new float[3];
            for (int i = 0; i < ret.Length; ++i)
            {
                ret[i] = ReadFloat();
            }

            return ret;
        }

        public void WriteList<T>(List<T> list) where T : ICinematic
        {
            int count = list.Count;
            _bWriter.Write(count);
            for (int i = 0; i < count; ++i)
            {
                list[i].WriteAll(_bWriter);
            }
        }

        public List<T> ReadList<T>() where T : ICinematic, new()
        {
            List<T> ret = new List<T>();
            int count = _bReader.ReadInt32();
            for (int i = 0; i < count; ++i)
            {
                T obj = new T();
                obj.ReadAll(_bReader);
                ret.Add(obj);
            }

            return ret;
        }

        public void WriteListV3(List<float[]> posList)
        {
            int count = posList.Count;
            WriteInt(count);
            for (int i = 0; i < count; ++i)
            {
                WriteFloat(posList[i][0]);
                WriteFloat(posList[i][1]);
                WriteFloat(posList[i][2]);
            }
        }

        public List<float[]> ReadListV3()
        {
            List<float[]> ret = new List<float[]>();
            int count = _bReader.ReadInt32();
            for (int i = 0; i < count; ++i)
            {
                float[] v3 = new float[3];
                v3[0] = ReadFloat();
                v3[1] = ReadFloat();
                v3[2] = ReadFloat();

                ret.Add(v3);
            }

            return ret;
        }

        public void WriteV3Array(Vector3[] posList)
        {
            int count = posList.Length;
            WriteInt(count);
            for (int i = 0; i < count; ++i)
            {
                WriteFloat(posList[i].x);
                WriteFloat(posList[i].y);
                WriteFloat(posList[i].z);
            }
        }

        public Vector3[] ReadV3Array()
        {
            int count = _bReader.ReadInt32();
            Vector3[] ret = new Vector3[count];
            for (int i = 0; i < count; ++i)
            {
                Vector3 v3 = new Vector3();
                v3.x = ReadFloat();
                v3.y = ReadFloat();
                v3.z = ReadFloat();

                ret[i] = v3;
            }

            return ret;
        }

        public Vector3[] ToV3Array(float[][] array)
        {
            Vector3[] v3Array = new Vector3[array.Length];
            for (int i = 0; i < v3Array.Length; ++i)
            {
                v3Array[i].x = array[i][0];
                v3Array[i].y = array[i][1];
                v3Array[i].z = array[i][2];
            }

            return v3Array;
        }
    }


}