BuYuHouDuan/UserSrc/UserApi/Hall/HallController.cs

using System.Linq;
using Common;
using CommonDomain.BaseModel;
using CommonInfrastructure;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using UserApi;
using UserDomain;
using UserDomain.Entity;
using UserService;
using UserService.Response;
using UserService.Param;
using UserService.Tasks;
using UserService.Tasks.Param;
using UserService.User;
using UserService.BattleOrder;
using UserService.GameConfigs;

namespace UserApi.Hall
{
    [ApiController, Route("api/[controller]")]
    [Authorize]

    public class HallController : BaseController
    {
        private readonly IUserService _userService;
        private readonly ITaskService _taskService;
        private readonly IBattleOrderService _battleOrderService;
        private readonly IActivityConfigService _activityConfigService;

        public HallController(IUserService userService, ITaskService taskService, IBattleOrderService battleOrderService, IActivityConfigService activityConfigService)
        {
            _userService = userService;
            _taskService = taskService;
            _battleOrderService = battleOrderService;
            _activityConfigService = activityConfigService;
        }


        [HttpGet("SaveSafeBox")]
        public async Task<BaseResponse<string>> SaveSafeBox(int gold)
        {
            var res = await _userService.SaveSafeBox(gold, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("GetSafeBox")]
        public async Task<BaseResponse<string>> GetSafeBox(long gold, string password)
        {
            var res = await _userService.GetSafeBox(gold, password, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("SetSafeBoxPassword")]
        public async Task<BaseResponse<string>> SetSafeBoxPassword(string password)
        {
            var res = await _userService.SetSafeBoxPassword(password, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }


        [HttpGet("ResetSafeBoxPassword")]
        public async Task<BaseResponse<string>> ResetSafeBoxPassword(string password, string code)
        {
            var res = await _userService.ResetSafeBoxPassword(password, code, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("GetRelief")]
        public async Task<BaseResponse<string>> GetRelief()
        {
            var res = await _userService.GetReliefGold(loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }


        [HttpGet("SynthesisFragment")]
        public async Task<BaseResponse<BaseProductCount>> SynthesisFragment(string propNumber)
        {
            var res = await _userService.SyntheticFragments(propNumber, loginUser);
            if (res.isok)
                return this.ToResult<BaseProductCount>(res.model);
            else
                return this.ToFailResult<BaseProductCount>(res.msg);
        }


     

        [HttpGet("BuyProp")]
        public async Task<BaseResponse<string>> BuyProp(string propNumber, int count = 1)
        {
            var res = await _userService.BuyProps(propNumber, count, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("UseVipExp")]
        public async Task<BaseResponse<string>> UseVipExp(int count = 1)
        {
            var res = await _userService.UseVipExp(count, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("BuyGold")]
        public async Task<BaseResponse<string>> BuyGold(string number, int count = 1)
        {
            var res = await _userService.BuyGold(number, count, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }



        [HttpGet("BuyDiamond")]
        public async Task<BaseResponse<string>> BuyDiamond(string number, int count = 1)
        {
            var res = await _userService.BuyDiamond(number, count, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.url);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("SignIn")]
        public async Task<BaseResponse<SignRewardResult>> SignIn()
        {
            var res = await _userService.Sign(loginUser);
            if (res.isok)
                return this.ToResult(res.result);
            else
                return this.ToFailResult<SignRewardResult>(res.msg);
        }

        [HttpGet("GetSignStatus")]
        public async Task<BaseResponse<SignStatusResult>> GetSignStatus()
        {
            var res = await _userService.GetSignStatus(loginUser);
            return this.ToResult(res);
        }


        [HttpGet("ChangeCannon")]
        public async Task<BaseResponse<string>> ChangeCannon(string number)
        {
            var res = await _userService.ChangeCannon(number, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }




        [HttpGet("ChangeWing")]
        public async Task<BaseResponse<string>> ChangeWing(string number)
        {
            var res = await _userService.ChangeWing(number, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("ChangeGodWar")]
        public async Task<BaseResponse<string>> ChangeGodWar(string number)
        {
            var res = await _userService.ChangeGodWar(number, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("UnloadCannon")]
        public async Task<BaseResponse<string>> UnloadCannon(string number)
        {
            var res = await _userService.UnloadCannon(number, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("UnloadWing")]
        public async Task<BaseResponse<string>> UnloadWing(string number)
        {
            var res = await _userService.UnloadWing(number, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }

        [HttpGet("UnloadGodWar")]
        public async Task<BaseResponse<string>> UnloadGodWar(string number)
        {
            var res = await _userService.UnloadGodWar(number, loginUser);
            if (res.isok)
                return this.ToResult<string>(res.msg);
            else
                return this.ToFailResult<string>(res.msg);
        }



        [HttpGet("GetVipDayGift")]
        public async Task<BaseResponse<GiftResponse>> GetVipDayGift()
        {
            var res = await _userService.GetVipDayGift(loginUser);
            if (res.isok)
                return this.ToResult<GiftResponse>(res.model);
            else
                return this.ToFailResult<GiftResponse>(res.msg);
        }


        [HttpGet("GetVipGift")]
        public async Task<BaseResponse<GiftResponse>> GetVipGift(int vipLevel)
        {
            var res = await _userService.GetVipGift(vipLevel, loginUser);
            if (res.isok)
                return this.ToResult<GiftResponse>(res.model);
            else
                return this.ToFailResult<GiftResponse>(res.msg);
        }



       
        [HttpGet("GetUserTaskList")]
        [Authorize]
        public async Task<ListResponse<UserTaskDto>> GetUserTaskList(int taskType)
        {
            var result = await _taskService.GetUserTaskList(new GetUserTaskListParam() { TaskType = taskType }, loginUser.UserId);
            var dtos = result.Select(MapToUserTaskDto).ToList();
            return this.ToListResult(dtos);
        }

        private static UserTaskDto MapToUserTaskDto(UserTask entity)
        {
            if (entity == null) return new UserTaskDto();
            return new UserTaskDto
            {
                Id = entity.Id ?? "",
                UserId = entity.UserId ?? "",
                Number = entity.Number ?? "",
                Remark = entity.Remark ?? "",
                TaskType = (int)entity.TaskType,
                TaskEvent = (int)entity.TaskEvent,
                TaskCount = entity.TaskCount,
                Count = entity.Count,
                IsFinish = entity.IsFinish,
                OtherId = entity.OtherId ?? "",
                IsGet = entity.IsGet,
                TaskAddTime = entity.TaskAddTime,
                TaskEndTime = entity.TaskEndTime,
                TaskFinishTime = entity.TaskFinishTime,
                Exp = entity.Exp
            };
        }
        [HttpGet("DistributeRewards")]
        public async Task<BaseResponse<string>> DistributeRewards(string id)
        {
            var result = await _taskService.DistributeRewards(id, loginUser.UserId);
            if (result.isok)
                return this.ToResult(result.msg);
            else
                return this.ToFailResult<string>(result.msg);
        }

        [HttpPost("GetUserRewardList")]
        public async Task<PageResponse<UserRewardDto>> GetUserRewardList(GetUserRewardListParam param)
        {
            param.UserId = loginUser.UserId;
            var res = await _userService.GetUserRewardList(param);
            if(res.list==null || res.list.Count()==0)
                  return this.ToPageResult<UserRewardDto>(null, res.count);
            var dtos = res.list.Select(MapToUserRewardDto).ToList();
            return this.ToPageResult(dtos, res.count);
        }

        private static UserRewardDto MapToUserRewardDto(UserReward entity)
        {
            if (entity == null) return new UserRewardDto();
            return new UserRewardDto
            {
                Id = entity.Id ?? "",
                UserId = entity.UserId ?? "",
                Type = entity.Type,
                Source = (int)entity.Source,
                CurrencyType = entity.CurrencyType,
                BeforeCount = entity.BeforeCount,
                ChangeCount = entity.ChangeCount,
                AfterCount = entity.AfterCount,
                OtherId = entity.OtherId ?? "",
                OtherUserId = entity.OtherUserId ?? "",
                Remark = entity.Remark ?? "",
                RoomName = entity.RoomName ?? "",
                RoomInfo = entity.RoomInfo ?? "",
                Tax = entity.Tax,
                CreateTime = entity.CreateTime
            };
        }



        public class UserTaskDto
        {
            public string Id { get; set; }
            public string UserId { get; set; }
            public string Number { get; set; }
            public string Remark { get; set; }
            public int TaskType { get; set; }
            public int TaskEvent { get; set; }
            public int TaskCount { get; set; }
            public double Count { get; set; }
            public bool IsFinish { get; set; }
            public string OtherId { get; set; }
            public bool IsGet { get; set; }
            public long TaskAddTime { get; set; }
            public long TaskEndTime { get; set; }
            public long TaskFinishTime { get; set; }
            public long Exp { get; set; }
        }

        public class UserRewardDto
        {
            public string Id { get; set; }
            public string UserId { get; set; }
            public int Type { get; set; }
            public int Source { get; set; }
            public int CurrencyType { get; set; }
            public long BeforeCount { get; set; }
            public long ChangeCount { get; set; }
            public long AfterCount { get; set; }
            public string OtherId { get; set; }
            public string OtherUserId { get; set; }
            public string Remark { get; set; }
            public string RoomName { get; set; }
            public string RoomInfo { get; set; }
            public int Tax { get; set; }
            public long CreateTime { get; set; }
        }



        [HttpGet("GetBattleOrder")]
        public async Task<BaseResponse<BattleOrderResponse>> GetBattleOrder()
        {
            var result = await _battleOrderService.GetUserBattleOrderWithConfigAsync(loginUser.UserId);
            return this.ToResult(result);
        }

        [HttpGet("GetBattleOrderLevelStatus")]
        public async Task<BaseResponse<BattleOrderLevelStatusResponse>> GetBattleOrderLevelStatus()
        {
            var result = await _battleOrderService.GetLevelRewardStatusAsync(loginUser.UserId);
            return this.ToResult(result);
        }

        [HttpGet("ReceiveAllBattleOrderRewards")]
        public async Task<ListResponse<GiftConfig>> ReceiveAllBattleOrderRewards()
        {
            var result = await _battleOrderService.ReceiveAllRewardsAsync(loginUser.UserId);
            if (result.success)
                return this.ToListResult(result.rewards);
            else
                return this.ToListFailResult<GiftConfig>(result.message);
        }

        [HttpGet("ReceiveBattleOrderLevelReward")]
        public async Task<ListResponse<GiftConfig>> ReceiveBattleOrderLevelReward( int level)
        {
            var result = await _battleOrderService.ReceiveLevelRewardAsync(loginUser.UserId, level);
            if (result.success)
                return this.ToListResult(result.rewards);
            else
                return this.ToListFailResult<GiftConfig>(result.message);
        }

        [HttpGet("BuyBattleOrderLevel")]
        public async Task<BaseResponse<BuyBattleOrderLevelResponse>> BuyBattleOrderLevel(int levelCount)
        {
            var result = await _battleOrderService.BuyLevelsAsync(loginUser.UserId, levelCount);
            if (result.success)
                return this.ToResult(new BuyBattleOrderLevelResponse
                {
                    NewLevel = result.newLevel,
                    Cost = result.cost
                });
            else
                return this.ToFailResult<BuyBattleOrderLevelResponse>(result.message);
        }

        [HttpGet("BuyBattleOrderAdvance")]
        public async Task<BaseResponse<BuyBattleOrderAdvanceResponse>> BuyBattleOrderAdvance(int type)
        {
            var result = await _battleOrderService.BuyAdvanceAsync(loginUser.UserId, type);
            if (result.success)
                return this.ToResult(new BuyBattleOrderAdvanceResponse
                {
                    Success = true,
                    Message = result.message,
                    PurchasedAdvances = result.purchasedAdvances
                });
            else
                return this.ToFailResult<BuyBattleOrderAdvanceResponse>(result.message);
        }

        [HttpGet("ReceiveAllTaskRewards")]
        public async Task<BaseResponse<object>> ReceiveAllTaskRewards()
        {
            var result = await _taskService.ReceiveAllTaskRewardsAsync(loginUser.UserId);
            if (result.success)
                return this.ToResult<object>(new { message = result.message, totalExp = result.totalExp });
            else
                return this.ToFailResult<object>(result.message);
        }

        [HttpGet("GetRanking")]
        public async Task<BaseResponse<RankingResponse>> GetRanking(int type = 1)
        {
            var config = await _activityConfigService.Get();
            var rankingConfig = config?.RankingRewardConfig;
            if (rankingConfig != null && rankingConfig.IsMaintaining)
            {
                return this.ToFailResult<RankingResponse>(
                    string.IsNullOrEmpty(rankingConfig.MaintainingMessage)
                        ? "当前排行榜正在维护中，请稍后再试"
                        : rankingConfig.MaintainingMessage);
            }
            var result = await _userService.GetRanking(loginUser, type);
            return this.ToResult(result);
        }

        [HttpGet("SendBroadcast")]
        public async Task<BaseResponse<string>> SendBroadcast(string message)
        {
            var res = await _userService.SendBroadcast(message, loginUser);
            if (res.isok)
                return this.ToResult(res.msg);
            return this.ToFailResult<string>(res.msg);
        }


        [AllowAnonymous]
        [HttpGet("GetChessRoomPartitionCount")]
        public async Task<BaseResponse<int>> GetChessRoomPartitionCount([FromServices] UserService.GameConfigs.IGameConfigService gameConfigService)
        {
            var config = await gameConfigService.Get();
            if (config == null)
                return this.ToFailResult<int>("配置不存在");

            var total = config.RoomConfigs
                .Where(r => r.GameType == CommonDomain.Enum.GameTypeEnum.中国象棋)
                .Sum(r => r.RoomPartitionNum);

            return this.ToResult(total);
        }
    }
}