using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Newtonsoft.Json.Linq;
using SLZ.Serialize;
 
#if UNITY_EDITOR
using UnityEditor;

#endif
namespace SLZ.Marrow.Warehouse
{
    public partial class Pallet : Scannable, ISerializationCallbackReceiver
    {
        [SerializeField]
        private string _author;
        public string Author
        {
            get
            {
                return _author;
            }

            set
            {
                _author = value;
            }
        }

        [SerializeField]
        private string _version = "0.0.0";
        public string Version
        {
            get
            {
                return _version;
            }

            set
            {
                _version = value;
            }
        }

        [SerializeField]
        private string _sdkVersion = MarrowSDK.SDK_VERSION;
        public string SDKVersion
        {
            get
            {
                return _sdkVersion;
            }

            set
            {
                _sdkVersion = value;
            }
        }

        [SerializeField]
        [Tooltip("NO LONGER USED")]
        private bool _internal = false;
        public bool Internal
        {
            [Obsolete("Use Pallet.IsInMarrowGame()")]
            get
            {
                return _internal;
            }

            set
            {
                _internal = value;
            }
        }

        [SerializeField]
        private List<Crate> _crates = new List<Crate>();
        public List<Crate> Crates
        {
            get
            {
                return _crates;
            }

            set
            {
                _crates = value;
            }
        }

        [SerializeField]
        private List<DataCard> _dataCards = new List<DataCard>();
        public List<DataCard> DataCards
        {
            get
            {
                return _dataCards;
            }

            set
            {
                _dataCards = value;
            }
        }

        [SerializeField]
        private List<string> _tags = new List<string>();
        public List<string> Tags
        {
            get
            {
                return _tags;
            }

            set
            {
                _tags = value;
            }
        }

        [System.Serializable]
        public struct ChangeLog
        {
            public string version;
            public string title;
            [TextArea(4, 20)]
            public string text;
            [Newtonsoft.Json.JsonConstructor]
            public ChangeLog(string version, string title, string text)
            {
                this.version = version;
                this.title = title;
                this.text = text;
            }
        }

        [SerializeField]
        private List<ChangeLog> _changeLogs = new List<ChangeLog>();
        public List<ChangeLog> ChangeLogs
        {
            get
            {
                return _changeLogs;
            }
        }

#if UNITY_EDITOR
        [SerializeField]
        private List<string> _crateTitles = new List<string>();
        [SerializeField]
        private List<string> _datacardTitles = new List<string>();
#endif
        public static readonly string PALLET_JSON_FILENAME = "pallet.json";
        public override void GenerateBarcodeInternal(bool forceGeneration = false)
        {
            Barcode.GenerateID(forceGeneration, Author, Title.Replace(".", ""));
            foreach (var crate in Crates)
            {
                crate.GenerateBarcode(true);
            }
        }

        public void GetScannables(ref List<Scannable> scannables)
        {
            scannables.Clear();
            scannables.AddRange(Crates);
            scannables.AddRange(DataCards);
        }

        [SerializeField]
        private List<PalletReference> _palletDependencies = new List<PalletReference>();
        public List<PalletReference> PalletDependencies
        {
            get
            {
                return _palletDependencies;
            }
        }

        public override void Pack(ObjectStore store, JObject json)
        {
            json.Add("barcode", Barcode.ID);
            json.Add("title", Title);
            json.Add("description", Description);
            json.Add("unlockable", Unlockable);
            json.Add("redacted", Redacted);
            json.Add("author", Author);
            json.Add("version", Version);
            json.Add("sdkVersion", SDKVersion);
            json.Add("internal", Internal);
            var jsonCrateArray = new JArray();
            foreach (var crate in Crates)
            {
                if (crate != null)
                {
                    jsonCrateArray.Add(store.PackReference(crate));
                }
            }

            json.Add(new JProperty("crates", jsonCrateArray));
            var jsonDataCardArray = new JArray();
            foreach (var dataCard in DataCards)
            {
                if (dataCard != null)
                {
                    jsonDataCardArray.Add(store.PackReference(dataCard));
                }
            }

            json.Add(new JProperty("dataCards", jsonDataCardArray));
            json.Add(new JProperty("tags", new JArray(Tags)));
            var changelogArray = new JArray();
            foreach (var changelog in ChangeLogs)
            {
                JObject logObject = new JObject();
                logObject.Add("version", changelog.version);
                logObject.Add("title", changelog.title);
                logObject.Add("text", changelog.text);
                changelogArray.Add(logObject);
            }

            json.Add(new JProperty("changelogs", changelogArray));
        }

        public override void Unpack(ObjectStore store, string objectId)
        {
            if (store.TryGetJSON("barcode", objectId, out JToken barcodeValue))
            {
                Barcode = new Barcode(barcodeValue.ToObject<string>());
            }

            if (store.TryGetJSON("title", objectId, out JToken titleValue))
            {
                name = titleValue.ToObject<string>();
                Title = titleValue.ToObject<string>();
            }

            if (store.TryGetJSON("description", objectId, out JToken descValue))
            {
                Description = descValue.ToObject<string>();
            }

            if (store.TryGetJSON("unlockable", objectId, out JToken unlockValue))
            {
                Unlockable = unlockValue.ToObject<bool>();
            }

            if (store.TryGetJSON("redacted", objectId, out JToken redaValue))
            {
                Redacted = redaValue.ToObject<bool>();
            }

            if (store.TryGetJSON("author", objectId, out JToken authorValue))
            {
                Author = authorValue.ToObject<string>();
            }

            if (store.TryGetJSON("version", objectId, out JToken versionValue))
            {
                Version = versionValue.ToObject<string>();
            }

            if (store.TryGetJSON("sdkVersion", objectId, out JToken sdkVersionValue))
            {
                SDKVersion = sdkVersionValue.ToObject<string>();
            }

            if (store.TryGetJSON("internal", objectId, out JToken internalValue))
            {
                Internal = internalValue.ToObject<bool>();
            }

            if (store.TryGetJSON("crates", objectId, out JToken cratesValue))
            {
                JArray arr = (JArray)cratesValue;
                Crates = new List<Crate>();
                foreach (var crateValue in arr)
                {
                    store.TryCreateFromReference(crateValue, out Crate crate, t => Crate.CreateCrate(t, null, "", new MarrowAsset(), false));
                    crate.Pallet = this;
                    Crates.Add(crate);
                }
            }

            if (store.TryGetJSON("dataCards", objectId, out JToken dataCardsValue))
            {
                JArray arr = (JArray)dataCardsValue;
                DataCards = new List<DataCard>();
                foreach (var dataCardValue in arr)
                {
                    store.TryCreateFromReference(dataCardValue, out DataCard dataCard, t => DataCard.CreateDataCard(t, null, "", false));
                    dataCard.Pallet = this;
                    DataCards.Add(dataCard);
                }
            }

            if (store.TryGetJSON("tags", objectId, out JToken tagsValue))
            {
                JArray arr = (JArray)tagsValue;
                Tags = new List<string>();
                foreach (var tagValue in arr)
                {
                    Tags.Add(tagValue.ToObject<string>());
                }
            }

            if (store.TryGetJSON("changelogs", objectId, out JToken changeLogsValue))
            {
                JArray arr = (JArray)changeLogsValue;
                ChangeLogs.Clear();
                foreach (var changeLogValue in arr)
                {
                    string version = changeLogValue["version"].ToObject<string>();
                    string title = changeLogValue["title"].ToObject<string>();
                    string text = changeLogValue["text"].ToObject<string>();
                    ChangeLogs.Add(new ChangeLog(version, title, text));
                }
            }
        }

        public static Pallet CreatePallet(string title, string author, bool generateBarcode = true)
        {
            Pallet pallet = ScriptableObject.CreateInstance<Pallet>();
            pallet.Title = title;
            pallet.Author = author;
            if (generateBarcode)
            {
                pallet.GenerateBarcode();
            }

            return pallet;
        }

        public void OnBeforeSerialize()
        {
#if UNITY_EDITOR
            _crateTitles.Clear();
            foreach (var crate in Crates)
            {
                if (crate != null)
                    _crateTitles.Add($"{Crate.GetCrateName(crate.GetType())}  {crate.Title}");
            }

            _datacardTitles.Clear();
            foreach (var dataCard in DataCards)
            {
                if (dataCard != null)
                    _datacardTitles.Add($"{dataCard.GetType().Name}  {dataCard.Title}");
            }
#endif
        }

        public void OnAfterDeserialize()
        {
#if UNITY_EDITOR
#endif
        }

#if UNITY_EDITOR
        [ContextMenu("Save Json to File")]
        private void SaveJsonToAssetDatabase()
        {
            string palletPath = AssetDatabase.GetAssetPath(this);
            palletPath = System.IO.Path.GetDirectoryName(palletPath);
            string palletJsonPath = System.IO.Path.Combine(palletPath, "_Pallet_" + MarrowSDK.SanitizeName(this.Barcode.ToString()) + ".json");
            PalletPacker.PackAndSaveToJson(this, palletJsonPath);
            AssetDatabase.Refresh();
        }

        [ContextMenu("Sort Contents")]
        public void SortCrates()
        {
            Crates.RemoveAll(item => item == null);
            Crates = Crates.OrderBy(crate => crate.GetType().Name).ThenBy(crate =>
            {
                var cratePath = AssetDatabase.GetAssetPath(crate);
                var crateFilename = System.IO.Path.GetFileName(cratePath);
                return crateFilename;
            }).ToList();
            DataCards.RemoveAll(item => item == null);
            DataCards = DataCards.OrderBy(dataCard => dataCard.GetType().Name).ThenBy(dataCard =>
            {
                var dataCardPath = AssetDatabase.GetAssetPath(dataCard);
                var dataCardFilename = System.IO.Path.GetFileName(dataCardPath);
                return dataCardFilename;
            }).ToList();
            EditorUtility.SetDirty(this);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }

        [ContextMenu("Fix Names")]
        public void FixNames()
        {
            AssetDatabase.StartAssetEditing();
            var palletItems = new List<Scannable>();
            palletItems.Add(this);
            palletItems.AddRange(Crates);
            palletItems.AddRange(DataCards);
            foreach (var scannable in palletItems)
            {
                string currentPath = AssetDatabase.GetAssetPath(scannable);
                string currentFileName = System.IO.Path.GetFileName(currentPath);
                string newFileName = scannable.GetAssetFilename();
                if (currentFileName.Substring(0, currentFileName.IndexOf('.')) != scannable.GetAssetFilenameTitle())
                    newFileName = $"{currentFileName.Substring(0, currentFileName.IndexOf('.'))}.{scannable.GetFullAssetExtension()}";
                if (!currentFileName.EndsWith(scannable.GetFullAssetExtension()))
                {
                    AssetDatabase.RenameAsset(currentPath, newFileName);
                }
            }

            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
            AssetDatabase.StopAssetEditing();
        }

        public override string GetAssetExtension()
        {
            return "pallet";
        }

        public static string GetAssetExtensionStatic()
        {
            return "pallet";
        }

        public override string GetAssetFilename()
        {
            return $"_{base.GetAssetFilename()}";
        }
#endif
    }
}