using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using MPQ.Updater;
using CommonLang.IO;
using System.Text.RegularExpressions;

namespace MPQ.FileSystem
{
    public class MPQFileSystem : IDisposable
    {
        private Dictionary<long, Dictionary<string, MPQFileEntry>> indexer = new Dictionary<long, Dictionary<string, MPQFileEntry>>();
        private Dictionary<string, MPQStream> mpq_files = new Dictionary<string, MPQStream>();
        /// <summary>
        /// 用于老文件存在，新目录已没有的文件
        /// </summary>
        private Dictionary<string, string> dir = new Dictionary<string, string>();

        public MPQFileSystem()
        {

        }
        /// <summary>
        /// 搜索并加载目录里的所有MPQ文件
        /// </summary>
        /// <param name="mpq_dir"></param>
        /// <returns></returns>
        public bool init(DirectoryInfo mpq_dir)
        {
            if (mpq_dir.Exists)
            {
                loadDir(new FileInfo(mpq_dir.FullName + Path.DirectorySeparatorChar + ".dir"));
                try
                {
                    foreach (FileInfo file in mpq_dir.GetFiles())
                    {
                        if (file.Extension.ToLower().EndsWith(MPQ.Updater.MPQUpdater.MPQ_EXT))
                        {
                            if (load(file.FullName) == null)
                            {
                                return false;
                            }
                        }
                    }
                    foreach (DirectoryInfo sub_dir in mpq_dir.GetDirectories())
                    {
                        if (!init(sub_dir))
                        {
                            return false;
                        }
                    }
                }
                finally
                {
                    dir.Clear();
                }
                return true;
            }
            return false;
        }
        /// <summary>
        /// 将自动更新的MPQ加载到文件系统
        /// </summary>
        /// <param name="updater"></param>
        /// <returns></returns>
        public bool init(MPQUpdater updater)
        {
            loadDir(new FileInfo(updater.LocalSaveRoot.FullName + Path.DirectorySeparatorChar + ".dir"));
            try
            {
                foreach (FileInfo rmf in updater.GetAllFiles())
                {
                    if (rmf.FullName.ToLower().EndsWith(MPQUpdater.MPQ_EXT))
                    {
                        if (load(rmf.FullName) == null)
                        {
                            return false;
                        }
                    }
                }
            }
            finally
            {
                dir.Clear();
            }
            return true;
        }
        private void loadDir(FileInfo dir_file)
        {
            if (dir_file.Exists)
            {
                string[] lines = File.ReadAllLines(dir_file.FullName);
                foreach (var line in lines)
                {
                    dir.Add(line.Trim(), line);
                }
            }
        }

        /// <summary>
        /// 加载单个MPQ文件到文件系统
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public MPQStream load(string path)
        {
            FileInfo fileinfo = new FileInfo(Path.GetFullPath(path));
            //Console.WriteLine("MPQFile::Load : " + fileinfo.FullName);
            List<MPQFileEntry> entries = new List<MPQFileEntry>(1000);
            MPQStream mpq_stream = new MPQStream(fileinfo);
            if (mpq_stream.loadEntrys(entries))
            {
                mpq_files[fileinfo.FullName] = mpq_stream;
                foreach (MPQFileEntry e in entries)
                {
                    if (dir.Count == 0 || dir.ContainsKey(e.Key))
                    {
                        putEntry(e);
                    }
                    else
                    {
                        Console.WriteLine(string.Format("MPQFileSystem : ignore entry \"{0}\" not exist in .dir file!!!", e.Key));
                    }
                }
                return mpq_stream;
            }
            else
            {
                mpq_stream.Dispose();
                throw new Exception("Cannot Init MPQ file : " + path);
            }
        }
        public void Dispose()
        {
            indexer.Clear();
            foreach (MPQStream path in mpq_files.Values)
            {
                path.Dispose();
            }
            mpq_files.Clear();
        }

        virtual protected long hashCode(string data)
        {
            return data.GetHashCode();
        }

        private bool putEntry(MPQFileEntry re)
        {
            re.hash = hashCode(re.key);

            Dictionary<string, MPQFileEntry> ets = null;
            // 首个HASH
            if (!indexer.TryGetValue(re.hash, out ets))
            {
                ets = new Dictionary<string, MPQFileEntry>(1);
                ets[re.key] = re;
                indexer[re.hash] = ets;
                return true;
            }
            // 首个文件
            MPQFileEntry exist = null;
            if (!ets.TryGetValue(re.key, out exist))
            {
                ets[re.key] = re;
                return true;
            }
            // 如果当前文件较新，则更新
            if (exist.f_date < re.f_date)
            {
                ets[re.key] = re;
                return true;
            }
            // 当前文件较老，忽略
            return false;
        }

        private MPQFileEntry findEntry(long hash, String name)
        {
            Dictionary<string, MPQFileEntry> ets = null;
            if (indexer.TryGetValue(hash, out ets))
            {
                MPQFileEntry ret = null;
                if (ets.TryGetValue(name, out ret))
                {
                    return ret;
                }
            }
            return null;
        }

        public MPQFileEntry findEntry(string path)
        {
            long hash = hashCode(path);
            return findEntry(hash, path);
        }

        public byte[] getEntryData(MPQFileEntry e)
        {
            if (e != null)
            {
                byte[] data = new byte[e.f_size];
                e.fs.Read(e, 0, data, 0, data.Length);
                return data;
            }
            return null;
        }
        public byte[] getData(String name)
        {
            long hash = hashCode(name);
            MPQFileEntry e = findEntry(hash, name);
            byte[] ed = getEntryData(e);
            return ed;
        }

        public Stream openEntryStream(MPQFileEntry e)
        {
            if (e != null)
            {
                return new EntryStream(e);
            }
            return null;
        }
        public Stream openStream(String name)
        {
            long hash = hashCode(name);
            MPQFileEntry e = findEntry(hash, name);
            Stream ed = openEntryStream(e);
            return ed;
        }

        public List<MPQFileEntry> listEntrys()
        {
            List<MPQFileEntry> ret = new List<MPQFileEntry>();
            foreach (Dictionary<string, MPQFileEntry> fe in indexer.Values)
            {
                foreach (MPQFileEntry e in fe.Values)
                {
                    ret.Add(e);
                }
            }
            return ret;
        }

        public List<MPQFileEntry> listEntrys(string pettern)
        {
            Regex regex = new Regex(pettern);
            List<MPQFileEntry> ret = new List<MPQFileEntry>();
            foreach (Dictionary<string, MPQFileEntry> fe in indexer.Values)
            {
                foreach (MPQFileEntry e in fe.Values)
                {
                    if (regex.IsMatch(e.key))
                    {
                        ret.Add(e);
                    }
                }
            }
            return ret;
        }

        //----------------------------------------------------------------------------------------------------------------------

        public class MPQStream : IDisposable
        {
            public static byte[] FS_HEAD_START = { (byte)'M', (byte)'F', (byte)'F', (byte)'S' };
            public static byte[] FS_ENTRY_START = { (byte)'M', (byte)'F', (byte)'E', (byte)'T' };
            public static byte[] FS_TRUNK_START = { (byte)'M', (byte)'F', (byte)'T', (byte)'K' };
            public static byte[] FS_END = { (byte)'M', (byte)'F', (byte)'E', (byte)'D' };
            public static byte[] VERSION = { 0, 0, 0, 1 };

            private FileInfo info;
            private FileStream fis;
            private long trunk_start;

            public long TrunkStart
            {
                get { return trunk_start; }
            }

            public FileInfo MPQFile
            {
                get { return info; }
            }

            public MPQStream(FileInfo file)
            {
                this.info = file;
                this.fis = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.Read);
            }

            private bool headEquals(byte[] a, byte[] b)
            {
                for (int i = 0; i < a.Length; i++)
                {
                    if (a[i] != b[i])
                    {
                        return false;
                    }
                }
                return true;
            }

            //             public List<MPQFileEntry> ListEntrys()
            //             {
            //                 List<MPQFileEntry> ret = new List<MPQFileEntry>();
            //                 if (loadEntrys(ret))
            //                 {
            //                 }
            //                 return ret;
            //             }

            public bool loadEntrys(List<MPQFileEntry> entries)
            {
                lock (fis)
                {
                    fis.Position = 0;
                    BinaryReader bis = new BinaryReader(fis, Encoding.UTF8);
                    byte[] head_trunk = IOUtil.ReadExpect(fis, MPQStream.FS_HEAD_START.Length); // head
                    if (headEquals(head_trunk, MPQStream.FS_HEAD_START))
                    {
                        head_trunk = IOUtil.ReadExpect(fis, MPQStream.VERSION.Length);// version
                        long total_size = bis.ReadInt64();
                        head_trunk = IOUtil.ReadExpect(fis, MPQStream.FS_ENTRY_START.Length);// entry start
                        if (headEquals(head_trunk, MPQStream.FS_ENTRY_START))
                        {
                            int entry_count = bis.ReadInt32();
                            for (int i = 0; i < entry_count; i++)
                            {
                                MPQFileEntry re = new MPQFileEntry();
                                re.fs = this;
                                re.load(bis);
                                entries.Add(re);
                            }
                            head_trunk = IOUtil.ReadExpect(fis, MPQStream.FS_TRUNK_START.Length);// trunk start
                            if (headEquals(head_trunk, MPQStream.FS_TRUNK_START))
                            {
                                // record file trunk start
                                this.trunk_start = fis.Position;
                                return true;
                            }
                        }
                    }
                }
                return false;
            }

            public void Dispose()
            {
                try
                {
                    lock (fis)
                    {
                        fis.Close();
                        fis.Dispose();
                    }
                }
                catch (Exception err)
                {
                    Console.WriteLine(err.Message + "\n" + err.StackTrace);
                }
            }

            public int Read(MPQFileEntry src, long src_pos, byte[] dst, int dst_pos, int length)
            {
                if (src.fs == this)
                {
                    lock (fis)
                    {
                        try
                        {
                            fis.Position = trunk_start + src.f_start + src_pos;
                            IOUtil.ReadToEnd(fis, dst, dst_pos, length);
                        }
                        catch (Exception err)
                        {
                            throw new Exception("MPQStream read error : " + err.Message, err);
                        }
                    }
                    return length;
                }
                throw new Exception("MPQStream read error");
            }

        }

        public class MPQFileEntry
        {
            internal static DateTime JAVA_START_DATE = new DateTime(1970, 1, 1, 0, 0, 0);

            internal long hash;         // 文件名HASH
                                        //internal int index;		    // HASH对应所在Entry位置
            internal String key;            // 文件名
                                            //internal int key_size;	    // 文件名长度
                                            //internal String key_md5;	// 文件名MD5
            internal int f_start;           // 文件内容开始位置
            internal int f_size;            // 文件内容尺寸
            internal long f_date;           // 文件日期（1970-1-1起始秒） 
                                            //internal String f_md5;		// 文件内容MD5

            internal MPQFileSystem.MPQStream fs;

            public string Key
            {
                get { return key; }
            }
            public int Size
            {
                get { return f_size; }
            }
            public DateTime Date
            {
                get { return JAVA_START_DATE.AddSeconds(f_date); }
            }

            public override string ToString()
            {
                return key + "(" + f_size + ")";
            }

            public byte[] getFileData()
            {
                byte[] data = new byte[this.f_size];
                this.fs.Read(this, 0, data, 0, data.Length);
                return data;
            }

            internal void load(BinaryReader bis)
            {
                /*
                 * hash 		= LittleIODeserialize.getLong	(is);
                 * index	 	= LittleIODeserialize.getInt	(is);
                 * key			= LittleIODeserialize.getString	(is, "UTF-8");
                 * key_size 	= LittleIODeserialize.getInt	(is);
                 * key_md5 	    = LittleIODeserialize.getString	(is, "UTF-8");
                 * f_start 	    = LittleIODeserialize.getInt	(is);
                 * f_size 		= LittleIODeserialize.getInt	(is);
                 * f_date 		= LittleIODeserialize.getLong	(is);
                 * f_md5 		= LittleIODeserialize.getString	(is, "UTF-8");
                 */
                this.hash = bis.ReadInt64();
                bis.ReadInt32();
                this.key = readUTF(bis);
                bis.ReadInt32();
                readUTF(bis);
                this.f_start = bis.ReadInt32();
                this.f_size = bis.ReadInt32();
                this.f_date = bis.ReadInt64();
                readUTF(bis);
            }

            private static string readUTF(BinaryReader bis)
            {
                int len = bis.ReadUInt16();
                byte[] bytes = new byte[len];
                int readed = bis.Read(bytes, 0, len);
                while (readed < len)
                {
                    readed += bis.Read(bytes, readed, len - readed);
                }
                return Encoding.UTF8.GetString(bytes, 0, len);
            }

            public bool Equals(MPQFileEntry b)
            {
                if (!b.key.Equals(this.key)) return false;
                if (!b.f_size.Equals(this.f_size)) return false;
                if (!b.f_date.Equals(this.f_date)) return false;
                if (!b.f_start.Equals(this.f_start)) return false;
                return true;
            }

        }

        /// <summary>
        /// 外部读取用流
        /// </summary>
        internal class EntryStream : Stream
        {
            private long pos = 0;
            private MPQFileEntry e;

            public EntryStream(MPQFileEntry entry)
            {
                this.e = entry;
            }
            public override long Position
            {
                get { return pos; }
                set { pos = value; }
            }
            public override long Length
            {
                get { return e.Size; }
            }
            public override bool CanRead
            {
                get { return true; }
            }
            public override bool CanSeek
            {
                get { return false; }
            }
            public override bool CanWrite
            {
                get { return false; }
            }
            public override int Read(byte[] buffer, int offset, int count)
            {
                long avaliable = e.Size - pos;
                if (avaliable > 0)
                {
                    count = (int)Math.Min(avaliable, count);
                    int readed = e.fs.Read(e, pos, buffer, offset, count);
                    pos += readed;
                    return readed;
                }
                else if (avaliable == 0)
                {
                    return 0;
                }
                throw new IOException("EOF of MPQEntry");
            }
            public override long Seek(long offset, SeekOrigin origin)
            {
                throw new NotImplementedException();
            }
            public override void SetLength(long value)
            {
                throw new NotImplementedException();
            }
            public override void Write(byte[] buffer, int offset, int count)
            {
                throw new NotImplementedException();
            }
            public override void Flush()
            {
            }
        }
    }

}