using Furion.DatabaseAccessor;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using YD_Event.Application.Team.Dtos;
using YD_Event.Application.Auth;
using YD_Event.Core.Entities;
using YD_Event.Core.Enum;

namespace YD_Event.Application.Team;

/// <summary>
/// 团队管理服务
/// </summary>
public class TeamService : BaseService<Core.Entities.Team>, IDynamicApiController, ITransient
{
    private readonly ISqlSugarRepository<Core.Entities.Team> _teamRep;
    private readonly ISqlSugarRepository<TeamMember> _memberRep;
    private readonly ISqlSugarRepository<Core.Entities.AppUser> _userRep;
    private readonly AuthManager _authManager;
    private readonly ISqlSugarClient _db;

    public TeamService(
        ISqlSugarRepository<Core.Entities.Team> teamRep,
        ISqlSugarRepository<TeamMember> memberRep,
        ISqlSugarRepository<Core.Entities.AppUser> userRep,
        AuthManager authManager,
        ISqlSugarClient db) : base(teamRep)
    {
        _teamRep = teamRep;
        _memberRep = memberRep;
        _userRep = userRep;
        _authManager = authManager;
        _db = db;
    }

    private async Task<(long userId, long? merchantCertificationId)> GetCurrentUserAndMerchantCertificationId()
    {
        var userId = _authManager.UserId;
        
        var certification = await _db.Queryable<MerchantCertification>()
            .FirstAsync(c => c.UserId == userId && !c.DeleteMark);
        
        return (userId, certification?.Id);
    }

    private async Task CheckPermission(Core.Entities.Team team)
    {
        var (userId, merchantCertificationId) = await GetCurrentUserAndMerchantCertificationId();
        
        if (merchantCertificationId.HasValue)
        {
            if (team.MerchantCertificationId != merchantCertificationId.Value) throw Oops.Bah("无权操作该团队");
        }
        else
        {
            if (team.CreatedUserId != userId || team.MerchantCertificationId != null) throw Oops.Bah("无权操作该团队");
        }
    }

    /// <summary>
    /// 分页查询团队
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet("page")]
    [DisplayName("分页查询团队")]
    public async Task<PageResult<TeamOutput>> Page([FromQuery] TeamQueryInput input)
    {
        var (userId, merchantCertificationId) = await GetCurrentUserAndMerchantCertificationId();

        var query = _teamRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.Name), t => t.Name.Contains(input.Name))
            .WhereIF(input.Status.HasValue, t => t.Status == input.Status)
            .WhereIF(input.StartTime.HasValue, t => t.CreatedTime >= input.StartTime)
            .WhereIF(input.EndTime.HasValue, t => t.CreatedTime <= input.EndTime)
            .OrderByDescending(t => t.CreatedTime);

        if (merchantCertificationId.HasValue)
        {
            query = query.Where(t => t.MerchantCertificationId == merchantCertificationId.Value);
        }
        else
        {
            query = query.Where(t => t.CreatedUserId == userId && t.MerchantCertificationId == null);
        }

        var list = await query.ToPagedListAsync(input);
        
        var result = list.Adapt<PageResult<TeamOutput>>();
        
        if (result.Rows.Any())
        {
            var teamIds = result.Rows.Select(x => x.Id).ToList();
            var members = await _memberRep.AsQueryable()
                .LeftJoin<Core.Entities.AppUser>((m, u) => m.UserId == u.Id)
                .Where(m => teamIds.Contains(m.TeamId) && (m.PersonType == PersonType.Leader || m.PersonType == PersonType.Coach))
                .Select((m, u) => new { m.TeamId, m.PersonType, u.Name })
                .ToListAsync();

            foreach (var item in result.Rows)
            {
                item.LeaderNames = string.Join(", ", members.Where(m => m.TeamId == item.Id && m.PersonType == PersonType.Leader).Select(m => m.Name));
                item.CoachNames = string.Join(", ", members.Where(m => m.TeamId == item.Id && m.PersonType == PersonType.Coach).Select(m => m.Name));
            }
        }

        return result;
    }

    /// <summary>
    /// 获取团队详情
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    [HttpGet("{id}")]
    [DisplayName("获取团队详情")]
    public async Task<TeamDetailOutput> Detail([FromRoute] long id)
    {
        var team = await _teamRep.GetFirstAsync(t => t.Id == id);
        if (team == null) throw Oops.Bah("团队不存在");

        await CheckPermission(team);

        var output = team.Adapt<TeamDetailOutput>();

        var members = await _memberRep.AsQueryable()
            .LeftJoin<Core.Entities.AppUser>((m, u) => m.UserId == u.Id)
            .Where(m => m.TeamId == id)
            .Select((m, u) => new TeamMemberOutput
            {
                UserId = m.UserId,
                Name = u.Name,
                Mobile = u.Mobile,
                PersonType = m.PersonType,
                Gender = u.Gender,
                BirthDate = u.BirthDate,
                IdCardNumber = u.IdCardNumber
            })
            .ToListAsync();

        output.Members = members;
        return output;
    }

    /// <summary>
    /// 新增团队
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("add")]
    [DisplayName("新增团队")]
    public async Task Add([FromBody] AddTeamInput input)
    {
        var (userId, merchantCertificationId) = await GetCurrentUserAndMerchantCertificationId();

        var isExist = await _teamRep.IsAnyAsync(t => t.Name == input.Name);
        if (isExist) throw Oops.Bah("团队名称已存在");

        var team = input.Adapt<Core.Entities.Team>();
        team.Status = AvailabilityStatus.Enable;
        team.MerchantCertificationId = merchantCertificationId;
        team.CreatedUserId = userId;
        team.CreatedTime = DateTime.Now;

        await _teamRep.AsSugarClient().Ado.UseTranAsync(async () =>
        {
            var newTeam = await _teamRep.InsertReturnEntityAsync(team);
            var members = new List<TeamMember>();

            members.AddRange(input.LeaderIds.Select(uid => new TeamMember { TeamId = newTeam.Id, UserId = uid, PersonType = PersonType.Leader, JoinTime = DateTime.Now, CreatedUserId = userId, CreatedTime = DateTime.Now }));
            members.AddRange(input.CoachIds.Select(uid => new TeamMember { TeamId = newTeam.Id, UserId = uid, PersonType = PersonType.Coach, JoinTime = DateTime.Now, CreatedUserId = userId, CreatedTime = DateTime.Now }));
            members.AddRange(input.MemberIds.Select(uid => new TeamMember { TeamId = newTeam.Id, UserId = uid, PersonType = PersonType.Athlete, JoinTime = DateTime.Now, CreatedUserId = userId, CreatedTime = DateTime.Now }));

            await _memberRep.InsertRangeAsync(members);
        });
    }

    /// <summary>
    /// 删除团队
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [HttpDelete("delete")]
    [DisplayName("删除团队")]
    public override async Task Delete(Core.Shared.KeyDto dto)
    {
        var team = await _teamRep.GetFirstAsync(t => t.Id == dto.Id);
        if (team == null) throw Oops.Bah("团队不存在");

        await CheckPermission(team);

        await _teamRep.AsSugarClient().Ado.UseTranAsync(async () =>
        {
            await base.Delete(dto);
            await _memberRep.SoftDeleteAsync(x => x.TeamId == dto.Id);
        });
    }

    /// <summary>
    /// 批量删除团队
    /// </summary>
    /// <param name="ids"></param>
    /// <returns></returns>
    [HttpPost("batchDelete")]
    [DisplayName("批量删除团队")]
    public async Task BatchDelete([FromBody] List<long> ids)
    {
        if (ids == null || !ids.Any()) throw Oops.Bah("请选择要删除的记录");

        var (userId, merchantCertificationId) = await GetCurrentUserAndMerchantCertificationId();
        var teams = await _teamRep.AsQueryable().Where(t => ids.Contains(t.Id)).ToListAsync();

        foreach (var team in teams)
        {
            await CheckPermission(team);
        }

        await _teamRep.AsSugarClient().Ado.UseTranAsync(async () =>
        {
            await _teamRep.SoftDeleteByIdsAsync(ids);
            await _memberRep.SoftDeleteAsync(x => ids.Contains(x.TeamId));
        });
    }

    /// <summary>
    /// 修改团队
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPut("update")]
    [DisplayName("修改团队")]
    public async Task Update([FromBody] UpdateTeamInput input)
    {
        var team = await _teamRep.GetFirstAsync(t => t.Id == input.Id);
        if (team == null) throw Oops.Bah("团队不存在");

        await CheckPermission(team);

        var isExist = await _teamRep.IsAnyAsync(t => t.Name == input.Name && t.Id != input.Id);
        if (isExist) throw Oops.Bah("团队名称已存在");

        input.Adapt(team);
        team.UpdatedUserId = _authManager.UserId;
        team.UpdatedTime = DateTime.Now;

        await _teamRep.AsSugarClient().Ado.UseTranAsync(async () =>
        {
            await _teamRep.UpdateAsync(team);

            await _memberRep.SoftDeleteAsync(m => m.TeamId == input.Id);

            var members = new List<TeamMember>();
            members.AddRange(input.LeaderIds.Select(uid => new TeamMember { TeamId = team.Id, UserId = uid, PersonType = PersonType.Leader, JoinTime = DateTime.Now, CreatedUserId = _authManager.UserId, CreatedTime = DateTime.Now }));
            members.AddRange(input.CoachIds.Select(uid => new TeamMember { TeamId = team.Id, UserId = uid, PersonType = PersonType.Coach, JoinTime = DateTime.Now, CreatedUserId = _authManager.UserId, CreatedTime = DateTime.Now }));
            members.AddRange(input.MemberIds.Select(uid => new TeamMember { TeamId = team.Id, UserId = uid, PersonType = PersonType.Athlete, JoinTime = DateTime.Now, CreatedUserId = _authManager.UserId, CreatedTime = DateTime.Now }));
            await _memberRep.InsertRangeAsync(members);
        });
    }
}