using Cal.DataTable;

using System;
using System.Collections.Generic;
using System.Text;

namespace ET
{

    public class StoreComponentAwakeSystem : AwakeSystem<StoreComponent>
    {
        public override void Awake(StoreComponent self)
        {
            StoreComponent.Instance = self;
        }
    }

    public static class StoreComponentSystem
    {
        public static readonly int[] extandStorePrice = new[]
        {
            100*10000,200*10000,400*10000,800*10000,1600*10000,3200*10000,6400*10000,12800*10000,25600*10000,51200*10000,
            200,300,400,600,800,1000,1500,3000,3000,3000
        };
        public const int RemoteStorePrice = 150 * 10000;
        public static async ETTask<Store> Query(this StoreComponent self, long id)
        {
            if (!self.StoreDic.TryGetValue(id, out var store))
            {
                store = await DBComponent.Instance.Query<Store>(id);
                if (store == null)
                {
                    store = EntityFactory.CreateWithId<Store>(self, id);
                }
                self.StoreDic[id] = store;
            }
            return store;
        }
        public static async ETTask Save(this StoreComponent self, Store store)
        {
            await DBComponent.Instance.Save(store);
        }
        public static async ETTask Init(this StoreComponent self, long id)
        {
            var store = await self.Query(id);
            store.Init();
            await DBComponent.Instance.Save(store);
        }

        public static async ETTask<(string, long, int)> GetStore(this StoreComponent self, Unit unit, int page, System.Collections.Generic.List<BagMap> storeList)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return ("系统错误", 0, 0);
            }
            if (page >= store.Max_Page)
            {
                Log.Error($"【{ UserComponent.Instance.Get(unit.Id)?.NickName} ({ unit.Id})】想要获取page = {page}的仓库界面,超过界限");
                return ("系统错误", 0, 0);
            }
            try
            {
                if (store.StoreDic.Count == 0)
                {
                    await self.Init(unit.Id);
                }
                GetUpdatedList(store, unit.Id, page, storeList);
            }
            catch (Exception e)
            {
                Log.Error(e);
            }

            return (string.Empty, store.CoinCount, store.Max_Page);
        }
        public static async ETTask<string> SortStore(this StoreComponent self, Unit unit, int page, System.Collections.Generic.List<BagMap> storeList)
        {
            await ETTask.CompletedTask;
            return "修复中";
            //Store store = await self.Query(unit.Id);
            //if (store == null)
            //{
            //    Log.Error($"store == null where id = {unit?.Id}");
            //    return "系统错误";
            //}
            //if (page >= store.Max_Page)
            //{
            //    Log.Error($"【{ UserComponent.Instance.Get(unit.Id)?.NickName} ({ unit.Id})】想要获取page = {page}的仓库界面");
            //    return "系统错误";
            //}
            //var now = TimeHelper.ClientNow();
            //if (now - store.lastSortTime <= 0*store.SortTimeInterval)
            //{
            //    return $"请等待{(store.lastSortTime + store.SortTimeInterval - now) / 1000}s之后再整理";
            //}
            //store.lastSortTime = now;
            //store.SortStore(page);
            //GetUpdatedList(store, unit.Id, page, storeList);
            //return string.Empty;
        }
        public static bool CanAddItem(this StoreComponent self, Unit unit, Store store, int itemId, int count)
        {
            var itemBase = BagHelper.GetItemBase(itemId);
            switch (itemBase)
            {
                case EquipBase equipBase:
                    return store.CanAddNewItem;
                case GoodsBase goodsBase:
                case MaterialBase materialBase:
                    return store.CanAddItem(itemId, count);
            }
            return false;
        }
        public static async ETTask<(string, int, int)> QueryExtand(this StoreComponent self, Unit unit)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return ("系统错误", 0, 0);
            }
            //!money
            int index = store.Max_Page - Store.InitMax_Page;
            if (index >= extandStorePrice.Length)
            {
                return ("背包已经无法扩展", 0, 0);
            }
            int price = extandStorePrice[index];
            int coin = 0, voucher = 0;
            if (index >= 10)
                voucher = price;
            else
                coin = price;

            return (null, coin, voucher);
        }
        public static async ETTask<string> ExtandStore(this StoreComponent self, Unit unit)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return "系统错误";
            }
            //!money
            int index = store.Max_Page - Store.InitMax_Page;
            if (index >= extandStorePrice.Length)
            {
                return "背包已经无法扩展";
            }
            int price = extandStorePrice[index];
            if (index >= 10)
            {
                //!代金券
                var ret = CharacterHelper.ReduceMoney(unit, CharacterHelper.MoneyType.Voucher, price);
                if (ret != null)
                    return ret;
            }
            else
            {
                //!金币
                var ret = CharacterHelper.ReduceMoney(unit, CharacterHelper.MoneyType.Coin, price);
                if (ret != null)
                    return ret;
            }

            store.ExtandStore();
            await self.Save(store);
            return null;
        }
        public static async ETTask<string> PutInStore(this StoreComponent self, Unit unit, int bagIndex, int count, int page, System.Collections.Generic.List<BagMap> storeList)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return "系统错误";
            }
            Bag bag = unit.GetComponent<Bag>();
            if (!bag.ItemDic.TryGetValueByKey1(bagIndex, out var item))
            {
                Log.Error($"【{ UserComponent.Instance.Get(unit.Id)?.NickName} ({ unit.Id})】想把背包中Index= {bagIndex}不存在的物品存入仓库");
                return "系统错误";
            }
            if (item.Count < count)
            {
                return "物品数量不足";
            }
            if (!CanAddItem(self, unit, store, item.ItemId, count))
            {
                return "仓库已满，无法存放！";
            }
            //!从背包中移除
            bag.DeleteItem(bagIndex, count);

            store.AddItem(new Item(0, item.data, count));


            UnitHelper.SaveComponenet(bag).Coroutine();
            await DBComponent.Instance.Save(store);
            //!获取更新后的列表
            GetUpdatedList(store, unit.Id, page, storeList);
            return string.Empty;
        }
        public static async ETTask<string> TakeOutStore(this StoreComponent self, Unit unit, int storeIndex, int count, int page, System.Collections.Generic.List<BagMap> storeList)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return "系统错误";
            }
            storeIndex += page * Store.Slot_PerPage;
            if (!store.StoreDic.TryGetValueByKey1(storeIndex, out var item))
            {
                Log.Error($"【{ UserComponent.Instance.Get(unit.Id)?.NickName} ({ unit.Id})】想要获取 storeIndex = {storeIndex}的仓库物品,但是不存在");
                return "系统错误";
            }
            if (item.Count < count)
            {
                return "物品数量不足";
            }
            Item removeItem = store.DeleteItem(storeIndex, count);
            if (removeItem == null)
            {
                Log.Error($"【{ UserComponent.Instance.Get(unit.Id)?.NickName} ({ unit.Id})】仓库物品Index = {storeIndex}被取出时失败");
            }
            Bag bag = unit.GetComponent<Bag>();
            bag.AddItem(new Item(0, removeItem.data, count));

            UnitHelper.SaveComponenet(bag).Coroutine();
            await DBComponent.Instance.Save(store);
            //!获取更新后的列表
            GetUpdatedList(store, unit.Id, page, storeList);
            return string.Empty;
        }
        /// <summary>
        /// 获取更新后的列表
        /// </summary>
        /// <param name="store"></param>
        /// <param name="id"></param>
        /// <param name="page"></param>
        /// <param name="storeList"></param>
        private static void GetUpdatedList(Store store, long id, int page, System.Collections.Generic.List<BagMap> storeList)
        {

            int index = -1, listcount = Store.Slot_PerPage;
            foreach (var _item in store.StoreDic.Values)
            {
                if (listcount <= 0) break;
                index++;
                if (index >= page * Store.Slot_PerPage && index < (page + 1) * Store.Slot_PerPage)
                {
                    listcount--;
                    if (_item.IsEmpty)
                    {
                        continue;
                    }
                    BagMap bagMap = new BagMap
                    {
                        Index = _item.index,
                        NetItem = new NetItem(_item),
                    };
                    if (_item.ItemType == ItemType.EquipItem)
                    {
                        bagMap.EquipTransMessage = new EquipTransMessage(_item.data.As<EquipItem>());
                    }
                    storeList.Add(bagMap);
                }
            }
        }
        public static async ETTask<(string, long)> PutCoinInStore(this StoreComponent self, Unit unit, long coin)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return ("系统错误", 0);
            }
            if (store.CoinCount + coin > store.MaxCoinCount)
            {
                return ("已达上限，无法继续储存", 0);
            }
            string retStr = CharacterHelper.ReduceMoney(unit, CharacterHelper.MoneyType.Coin, coin);
            if (retStr != null)
            {
                //Log.Error($"玩家Id = {unit.Id}存入仓库铜钱数{coin}超过了持有数{unit.GetAsLong(NumericType.Coin)},客户端已经限制过");
                return ("金币不足", 0);
            }
            store.CoinCount += coin;


            UnitHelper.Save<NumericComponent>(unit).Coroutine();
            await DBComponent.Instance.Save(store);

            return (string.Empty, store.CoinCount);
        }
        public static async ETTask<(string, long)> TakeCoinOutStore(this StoreComponent self, Unit unit, long coin)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return ("系统错误", 0);
            }
            if (store.CoinCount < coin)
            {
                //Log.Error($"玩家Id = {unit.Id}取出仓库铜钱数{coin}超过了存储数{store.CoinCount},客户端已经限制过");
                return ("取出数量大于存储数量", 0);
            }
            store.CoinCount -= coin;

            CharacterHelper.AddMoney(unit, CharacterHelper.MoneyType.Coin, coin);

            UnitHelper.Save<NumericComponent>(unit).Coroutine();
            await DBComponent.Instance.Save(store);

            return (string.Empty, store.CoinCount);
        }
        public static async ETTask SetOpenRemoteStore(this StoreComponent self, Unit unit,bool isOpen)
        {
            Store store = await self.Query(unit.Id);
            if (store == null)
            {
                Log.Error($"store == null where id = {unit?.Id}");
                return;
            }
            store.isOpenRemote = isOpen;
            return;
        }
    }
}