using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;

namespace Application.Web.Controllers.Pub;

/// <summary>
/// 装备接口
/// </summary>
[Route("[controller]/[action]")]
[ApiController]
[Authorize]
public class EquController : ControllerBase
{
    private readonly IGameEquService _equService;
    private readonly IUnitUserAttrService _attrService;
    private readonly IUnitUserService _userService;
    private readonly IGameDicService _dicService;
    private readonly IMessageService _messageService;

    public EquController(IGameEquService equService, IUnitUserAttrService attrService, IUnitUserService userService,
        IGameDicService dicService, IMessageService messageService)
    {
        _equService = equService;
        _attrService = attrService;
        _userService = userService;
        _dicService = dicService;
        _messageService = messageService;
    }

    /// <summary>
    /// 获取装备信息
    /// </summary>
    /// <param name="equId"></param>
    /// <param name="ueId"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetEquInfo(int? equId, string? ueId)
    {
        game_equ equInfo = new game_equ();
        game_equ_suit suit = new game_equ_suit();
        unit_user_equ ueInfo = new unit_user_equ();
        UserModel user = new UserModel();
        if (equId != 0)
        {
            equInfo = await _equService.GetEquInfo((int)equId);
            if (equInfo == null)
            {
                return PoAction.Message("装备不存在!");
            }

            if (equInfo.suitCode != "0" && !string.IsNullOrEmpty(equInfo.suitCode))
            {
                suit = await _equService.GetEuqSuitInfo(equInfo.suitCode);
            }
        }
        else
        {
            ueInfo = await _equService.GetUserEquInfo(ueId);
            if (ueInfo == null)
            {
                return PoAction.Message("装备不存在!");
            }

            equInfo = await _equService.GetEquInfo((int)ueInfo.equId);
            if (equInfo == null)
            {
                return PoAction.Message("装备不存在!");
            }

            if (ueInfo.suitCode != "0" && !string.IsNullOrEmpty(ueInfo.suitCode))
            {
                suit = await _equService.GetEuqSuitInfo(ueInfo.suitCode);
            }

            user = await UserModelTool.GetUserView(ueInfo.owerId);
        }

        return PoAction.Ok(new { equ = equInfo, suit, equData = ueInfo, user });
    }

    /// <summary>
    /// 获取套装详情
    /// </summary>
    /// <param name="suitCode"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetEquSuitInfo(string suitCode)
    {
        var data = await _equService.GetEuqSuitInfo(suitCode);
        if (data == null)
        {
            return PoAction.Message("套装不存在!");
        }

        return PoAction.Ok(data);
    }

    /// <summary>
    /// 绑定操作
    /// </summary>
    /// <param name="ueId"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> EquLock(string ueId)
    {
        var userId = StateHelper.userId;
        var equInfo = await _equService.GetUserEquInfo(ueId);
        if (equInfo == null)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.userId != userId)
        {
            return PoAction.Message("装备不存在!");
        }

        equInfo.isLock = equInfo.isLock == 0 ? 1 : 0;

        bool result = await _equService.UpdateUserEquInfo(equInfo);
        if (result)
        {
            string msg = equInfo.isLock == 1 ? "成功绑定装备!" : "成功解除装备绑定!";
            return PoAction.Ok(true, msg);
        }
        else
        {
            return PoAction.Message("操作失败,请稍后尝试!");
        }
    }

    /// <summary>
    /// 获取用户穿戴的装备
    /// </summary>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetUserOnEqu()
    {
        string userId = StateHelper.userId;
        var data = await _equService.GetUserOnEqu(userId);
        var suit = await _equService.GetUserEquSuit(userId);
        return PoAction.Ok(new { data, suit });
    }

    /// <summary>
    /// 穿/卸装备
    /// </summary>
    /// <param name="ueId"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> DownOrUpEqu(string ueId, string? de)
    {
        string userId = StateHelper.userId;
        var equInfo = await _equService.GetUserEquInfo(ueId);
        if (equInfo == null)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.userId != userId)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.isOn == 0) //穿装
        {
            if (equInfo.isAppr == 0)
            {
                return PoAction.Message("装备未鉴定!");
            }

            if (equInfo.useEndTime < TimeExtend.GetTimeStampSeconds)
            {
                return PoAction.Message("装备已过期!");
            }

            int myLev = await _attrService.GetUserLev(userId);
            if (equInfo.lev > myLev)
            {
                return PoAction.Message($"等级达到{equInfo.lev}级可穿戴!");
            }

            if (equInfo.sex != nameof(EquEnum.Sex.Default))
            {
                var userInfo = await _userService.GetUserInfoByUserId(userId);
                string needSex = equInfo.sex == nameof(EquEnum.Sex.Girl)
                    ? nameof(GameEnum.Sex.女)
                    : nameof(GameEnum.Sex.男);
                if (userInfo.sex != needSex)
                {
                    return PoAction.Message($"该装备只允许{needSex}性角色穿戴!");
                }
            }

            var userOnEqu = await _equService.GetUserOnEqu(userId);
            if (equInfo.canEqualUp > 0)
            {
                int onCount = userOnEqu.Count(it => it.equId == equInfo.equId);
                if (onCount >= equInfo.canEqualUp)
                {
                    return PoAction.Message($"该装备最多穿戴{equInfo.canEqualUp}件!");
                }
            }

            bool isOk = true;
            if (string.IsNullOrEmpty(de))
            {
                int MaxCount = GameTool.GetEquPlaceCount(equInfo.code);
                int OnCount = userOnEqu.Count(it => it.code == equInfo.code) + 1;
                if (OnCount > MaxCount)
                {
                    return PoAction.Message($"该部位装备最多穿戴{MaxCount}件!", 100);
                }
            }
            else
            {
                var DownOnEqu = await _equService.GetUserEquInfo(de);
                if (DownOnEqu == null)
                {
                    return PoAction.Message("装备不存在!");
                }

                if (userOnEqu.Any(it => it.ueId == de) == false)
                {
                    return PoAction.Message("装备未穿戴!");
                }

                if (DownOnEqu.code != equInfo.code)
                {
                    return PoAction.Message("装备部位不一致!");
                }

                isOk = await _equService.EquOnOrDown(DownOnEqu, 0);
            }

            if (isOk)
            {
                bool result = await _equService.EquOnOrDown(equInfo, 1);
                if (result)
                {
                    return PoAction.Ok(true, "穿装成功!");
                }
                else
                {
                    return PoAction.Message("穿装失败,请稍后尝试");
                }
            }
            else
            {
                return PoAction.Message("穿装失败,请稍后尝试");
            }
        }
        else //卸装
        {
            bool result = await _equService.EquOnOrDown(equInfo, 0);
            if (result)
            {
                return PoAction.Ok(true, "卸装成功!");
            }
            else
            {
                return PoAction.Message("卸装失败,请稍后尝试");
            }
        }
    }

    /// <summary>
    /// 获取可穿戴装备
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetCanOnEqu(int type)
    {
        string code = nameof(EquEnum.EquPlace.Hold);
        switch (type)
        {
            case 1:
                code = nameof(EquEnum.EquPlace.Hold);
                break;
            case 2:
                code = nameof(EquEnum.EquPlace.Vice);
                break;
            case 3:
                code = nameof(EquEnum.EquPlace.Head);
                break;
            case 4:
                code = nameof(EquEnum.EquPlace.Wear);
                break;
            case 5:
                code = nameof(EquEnum.EquPlace.Waist);
                break;
            case 6:
                code = nameof(EquEnum.EquPlace.Foot);
                break;
            case 7:
                code = nameof(EquEnum.EquPlace.Ornaments);
                break;
            case 8:
                code = nameof(EquEnum.EquPlace.Fashion);
                break;
            case 9:
                code = nameof(EquEnum.EquPlace.Wing);
                break;
            case 10:
                code = nameof(EquEnum.EquPlace.Decorate);
                break;
        }

        string userId = StateHelper.userId;
        var userOnEqu = await _equService.GetUserOnEqu(userId);
        var NoEqu = userOnEqu.FindAll(it => it.code == code).Select(it => it.ueId).ToList();
        var CanEqu = await _equService.GetUserEquData(userId, code, NoEqu);
        long onTime = TimeExtend.GetTimeStampSeconds;
        CanEqu = CanEqu.FindAll(it => it.isAppr == 1 && it.useEndTime > onTime);
        CanEqu = CanEqu.OrderByDescending(it => it.lev).ToList();
        return PoAction.Ok(CanEqu);
    }

    /// <summary>
    /// 获取激活套装属性
    /// </summary>
    /// <param name="suitCode"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetUserOnSuitInfo(string suitCode)
    {
        var userId = StateHelper.userId;
        var onSuit = await _equService.GetUserEquSuit(userId);
        var suit = onSuit.Find(it => it.suitCode == suitCode);
        if (suit == null)
        {
            return PoAction.Message("套装不存在!");
        }

        var data = await _equService.GetEuqSuitInfo(suitCode);
        if (data == null)
        {
            return PoAction.Message("套装不存在!");
        }

        return PoAction.Ok(new { data, suit });
    }

    /// <summary>
    /// 获取装备觉醒所需
    /// </summary>
    /// <param name="ue"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetEquAwakenInfo(string ue)
    {
        string userId = StateHelper.userId;
        var equData = await _equService.GetUserEquInfo(ue);
        if (equData == null)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equData.userId != userId)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equData.isAppr == 0)
        {
            return PoAction.Message("装备未鉴定!");
        }

        if (equData.useEndTime < TimeExtend.GetTimeStampSeconds)
        {
            return PoAction.Message("装备已过期!");
        }

        CheckTowerNeed result = new CheckTowerNeed();
        if (equData.EquAwaken.Count == 0)
        {
            var dicConfig = await _dicService.GetDicInfo(nameof(GameEnum.DicCode.Awaken));
            List<TowerNeed> need = JsonConvert.DeserializeObject<List<TowerNeed>>(dicConfig.sign);
            result = await GameBus.CheckNeed(userId, need);
        }
        else
        {
            var upAwaken =
                await _equService.GetEquAwakenInfoByLev(equData.EquAwaken[0].atId, equData.EquAwaken[0].lev + 1);
            if (upAwaken == null)
            {
                return PoAction.Message("觉醒已达到上限!");
            }

            result = await GameBus.CheckNeed(userId, upAwaken.need);
        }

        return PoAction.Ok(result);
    }

    /// <summary>
    /// 觉醒装备
    /// </summary>
    /// <param name="ue"></param>
    /// <param name="type">0重置，1正常觉醒</param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> HandleEquAwaken(string ue, int type)
    {
        string userId = StateHelper.userId;
        var equData = await _equService.GetUserEquInfo(ue);
        if (equData == null)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equData.userId != userId)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equData.isAppr == 0)
        {
            return PoAction.Message("装备未鉴定!");
        }

        if (equData.useEndTime < TimeExtend.GetTimeStampSeconds)
        {
            return PoAction.Message("装备已过期!");
        }

        EquAwakenData onAwaken = new EquAwakenData();
        game_equ_awaken newAwaken = new game_equ_awaken();
        CheckTowerNeed result = new CheckTowerNeed();
        if (type == 0) //重置
        {
            newAwaken = await _equService.GetRandomOneAwakenByCode(equData.code);
            if (newAwaken == null)
            {
                return PoAction.Message("该部件装备不可觉醒!");
            }

            onAwaken = newAwaken.levAttr.Find(it => it.lev == 1);
            var dicConfig = await _dicService.GetDicInfo(nameof(GameEnum.DicCode.Awaken));
            List<TowerNeed> need = JsonConvert.DeserializeObject<List<TowerNeed>>(dicConfig.sign);
            result = await GameBus.CheckNeed(userId, need);
        }
        else
        {
            if (equData.EquAwaken.Count == 0)
            {
                newAwaken = await _equService.GetRandomOneAwakenByCode(equData.code);
                if (newAwaken == null)
                {
                    return PoAction.Message("该部件装备不可觉醒!");
                }

                onAwaken = newAwaken.levAttr.Find(it => it.lev == 1);
                var dicConfig = await _dicService.GetDicInfo(nameof(GameEnum.DicCode.Awaken));
                List<TowerNeed> need = JsonConvert.DeserializeObject<List<TowerNeed>>(dicConfig.sign);
                result = await GameBus.CheckNeed(userId, need);
            }
            else
            {
                var upAwaken =
                    await _equService.GetEquAwakenInfoByLev(equData.EquAwaken[0].atId, equData.EquAwaken[0].lev + 1);
                if (upAwaken == null)
                {
                    return PoAction.Message("觉醒已达到上限!");
                }

                newAwaken = await _equService.GetEquAwakenInfo(equData.EquAwaken[0].atId);
                onAwaken = upAwaken;
                result = await GameBus.CheckNeed(userId, upAwaken.need);
            }
        }

        if (result.result == false)
        {
            return PoAction.Message("不满足觉醒条件!");
        }

        if (await GameBus.UpdateBag(userId, 0, result.Needs, "觉醒装备"))
        {
            if (RandomAssist.CheakRandom(onAwaken.success))
            {
                EquAwaken awaken = new EquAwaken();
                awaken.atId = newAwaken.atId;
                awaken.name = newAwaken.name;
                awaken.lev = onAwaken.lev;
                awaken.awaken = onAwaken.attr;
                equData.EquAwaken = [awaken];
                if (await _equService.UpdateUserEquInfo(equData, true, "觉醒", "装备觉醒"))
                {
                    string msg = $"[{equData.equName}]装备的特性【{awaken.name}】升至{awaken.lev}级!";
                    await _messageService.SendBroadcast(userId, nameof(MessageEnum.BroadcastCode.Promote), msg);
                    //此处为觉醒成功,返回相关数据
                    var nextAwaken =
                        await _equService.GetEquAwakenInfoByLev(equData.EquAwaken[0].atId,
                            equData.EquAwaken[0].lev + 1);
                    var nextResult = new CheckTowerNeed()
                    {
                        result = false,
                        Needs = new List<TowerNeed>()
                    };
                    if (nextAwaken != null)
                    {
                        nextResult = await GameBus.CheckNeed(userId, nextAwaken.need);
                    }

                    return PoAction.Ok(new { state = 1, awaken = equData.EquAwaken, result = nextResult }, "觉醒成功!");
                }
                else
                {
                    return PoAction.Message("觉醒异常,请稍后尝试!");
                }
            }
            else
            {
                //此处为觉醒成功,返回相关数据
                var nextAwaken =
                    await _equService.GetEquAwakenInfoByLev(equData.EquAwaken[0].atId,
                        equData.EquAwaken[0].lev + 1);
                var nextResult = new CheckTowerNeed()
                {
                    result = false,
                    Needs = new List<TowerNeed>()
                };
                if (nextAwaken != null)
                {
                    nextResult = await GameBus.CheckNeed(userId, nextAwaken.need);
                }

                return PoAction.Ok(new { state = 0, awaken = equData.EquAwaken, result = nextResult }, "觉醒失败!");
            }
        }
        else
        {
            return PoAction.Message("觉醒异常,请稍后尝试!");
        }

        return PoAction.Ok(result);
    }

    /// <summary>
    /// 获取强化信息
    /// </summary>
    /// <param name="ueId"></param>
    /// <returns></returns>
    [HttpGet]
    public async Task<IPoAction> GetEquUpInfo(string ueId)
    {
        string userId = StateHelper.userId;
        var equInfo = await _equService.GetUserEquInfo(ueId);
        if (equInfo == null)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.userId != userId)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.isAppr == 0)
        {
            return PoAction.Message("装备未鉴定!");
        }

        long time = TimeExtend.GetTimeStampSeconds;
        if (equInfo.useEndTime < time)
        {
            return PoAction.Message("装备已过期!");
        }

        if (equInfo.isIntensify == 0)
        {
            return PoAction.Message("装备不可强化!");
        }

        bool isMax = false;
        int upLev = (int)equInfo.intensifyLev + 1;
        var needs = await _equService.GetUserEquUpData(upLev);
        if (needs == null)
        {
            isMax = true;
        }

        CheckTowerNeeds result = new CheckTowerNeeds();
        result.result = false;
        result.Needs = new List<TowerNeeds>();
        if (!isMax)
        {
            result = await GameBus.CheckNeeds(userId, needs.needData);
        }

        return PoAction.Ok(new
        {
            equData = equInfo,
            isMax,
            result
        });
    }

    /// <summary>
    /// 强化装备
    /// </summary>
    /// <param name="parms"></param>
    /// <returns></returns>
    [HttpPost]
    public async Task<IPoAction> HandleEquUp([FromBody] EquUpParms parms)
    {
        string ueId = parms.ueId;
        string userId = StateHelper.userId;
        var equInfo = await _equService.GetUserEquInfo(ueId);
        if (equInfo == null)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.userId != userId)
        {
            return PoAction.Message("装备不存在!");
        }

        if (equInfo.isAppr == 0)
        {
            return PoAction.Message("装备未鉴定!");
        }

        long time = TimeExtend.GetTimeStampSeconds;
        if (equInfo.useEndTime < time)
        {
            return PoAction.Message("装备已过期!");
        }

        if (equInfo.isIntensify == 0)
        {
            return PoAction.Message("装备不可强化!");
        }

        int upLev = (int)equInfo.intensifyLev + 1;
        var needs = await _equService.GetUserEquUpData(upLev);
        if (needs == null)
        {
            return PoAction.Message("已达到最大强化等级!");
        }

        List<TowerNeeds> reqNeeds = JsonConvert.DeserializeObject<List<TowerNeeds>>(parms.needs);
        //验证材料
        foreach (var item in needs.needData)
        {
            var onNeed = reqNeeds.Find(it => it.Id == item.Id);
            if (item.NeedItem.Any(it => it.code == onNeed.code && it.parameter == onNeed.parameter) == false &&
                item.code != onNeed.code && item.parameter != onNeed.parameter)
            {
                return PoAction.Message("材料错误!");
            }
        }

        var result = await GameBus.CheckNeeds(userId, reqNeeds);
        if (result.result == false)
        {
            return PoAction.Message("材料不足!");
        }

        if (await GameBus.UpdateBag(userId, 0, reqNeeds, $"强化装备:{ueId}"))
        {
            CheckTowerNeeds nexResult = new CheckTowerNeeds();
            nexResult.result = false;
            nexResult.Needs = new List<TowerNeeds>();
            bool isMax = false;
            int state = 0;
            int okNum = (int)needs.okChance;
            if (RandomAssist.CheakRandom(okNum))
            {
                state = 1;
                equInfo.intensifyLev = upLev;
                equInfo.isDeal = result.isDeal;
                equInfo.isGive = result.isGive;
                if (await _equService.UpdateUserEquInfo(equInfo, true, "强化", "强化装备") == false)
                {
                    return PoAction.Message("强化异常,请联系客服!");
                }

                var nextNeeds = await _equService.GetUserEquUpData((int)equInfo.intensifyLev + 1);
                if (needs == null)
                {
                    isMax = true;
                }
                else
                {
                    var nexts = nextNeeds.euId == needs.euId ? reqNeeds : nextNeeds.needData;
                    nexResult = await GameBus.CheckNeeds(userId, nexts);
                }
            }
            else //执行材料返还
            {
                List<TowerGet> retProp = new List<TowerGet>();
                foreach (var item in reqNeeds)
                {
                    if (item.retCount > 0 && item.isOp == 1)
                    {
                        TowerGet temp = new TowerGet()
                        {
                            code = item.code,
                            name = item.name,
                            parameter = item.parameter,
                            count = item.count
                        };
                        retProp.Add(temp);
                    }
                }

                if (retProp.Count > 0)
                {
                    await GameBus.UpdateBag(userId, 1, retProp, "强化失败,返还");
                }

                nexResult = await GameBus.CheckNeeds(userId, reqNeeds);
            }


            return PoAction.Ok(new
            {
                state,
                equData = equInfo,
                isMax,
                result = nexResult
            });
        }
        else
        {
            return PoAction.Message("强化错误,请稍后尝试!");
        }
    }
}