using Admin.NET.Plugin.AiDOP.Dto;
using Admin.NET.Plugin.AiDOP.Entity;
using Admin.NET.Plugin.AiDOP.Infrastructure;

namespace Admin.NET.Plugin.AiDOP.Controllers;

[ApiController]
[Route("api/[controller]")]
[AllowAnonymous]
[NonUnify]
public class WorkOrderController : ControllerBase
{
    private readonly SqlSugarRepository<AdoWorkOrder> _workOrderRep;
    private readonly SqlSugarRepository<AdoPlan> _planRep;

    public WorkOrderController(
        SqlSugarRepository<AdoWorkOrder> workOrderRep,
        SqlSugarRepository<AdoPlan> planRep)
    {
        _workOrderRep = workOrderRep;
        _planRep = planRep;
    }

    [HttpGet]
    public async Task<IActionResult> GetWorkOrders([FromQuery] WorkOrderQueryDto query)
    {
        (query.Page, query.PageSize) = PagingGuard.Normalize(query.Page, query.PageSize);
        var q = _workOrderRep.AsQueryable();

        if (!string.IsNullOrWhiteSpace(query.WorkOrderNo))
            q = q.Where(x => x.WorkOrderNo.Contains(query.WorkOrderNo));
        if (!string.IsNullOrWhiteSpace(query.PlanNo))
            q = q.Where(x => x.PlanNo != null && x.PlanNo.Contains(query.PlanNo));
        if (!string.IsNullOrWhiteSpace(query.Status))
            q = q.Where(x => x.Status == query.Status);
        if (!string.IsNullOrWhiteSpace(query.WorkCenter))
            q = q.Where(x => x.WorkCenter == query.WorkCenter);

        var total = await q.CountAsync();
        var list = await q
            .OrderByDescending(x => x.CreatedTime)
            .Skip((query.Page - 1) * query.PageSize)
            .Take(query.PageSize)
            .ToListAsync();

        return Ok(new
        {
            total,
            page = query.Page,
            pageSize = query.PageSize,
            list = list.Select(x => new WorkOrderDetailDto
            {
                Id = x.Id,
                WorkOrderNo = x.WorkOrderNo,
                PlanNo = x.PlanNo,
                Product = x.Product,
                Quantity = x.Quantity,
                CompletedQuantity = x.CompletedQuantity,
                WorkCenter = x.WorkCenter,
                Team = x.Team,
                Owner = x.Owner,
                StartDate = x.StartDate,
                PlanEndDate = x.PlanEndDate,
                ActualEndDate = x.ActualEndDate,
                Status = x.Status,
                Priority = x.Priority,
                Remark = x.Remark,
                CreatedTime = x.CreatedTime,
                UpdatedTime = x.UpdatedTime,
                CreatedBy = x.CreatedBy
            }).ToList()
        });
    }

    [HttpGet("{id:long}")]
    public async Task<IActionResult> GetWorkOrder(long id)
    {
        var item = await _workOrderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        return Ok(new WorkOrderDetailDto
        {
            Id = item.Id,
            WorkOrderNo = item.WorkOrderNo,
            PlanNo = item.PlanNo,
            Product = item.Product,
            Quantity = item.Quantity,
            CompletedQuantity = item.CompletedQuantity,
            WorkCenter = item.WorkCenter,
            Team = item.Team,
            Owner = item.Owner,
            StartDate = item.StartDate,
            PlanEndDate = item.PlanEndDate,
            ActualEndDate = item.ActualEndDate,
            Status = item.Status,
            Priority = item.Priority,
            Remark = item.Remark,
            CreatedTime = item.CreatedTime,
            UpdatedTime = item.UpdatedTime,
            CreatedBy = item.CreatedBy
        });
    }

    [HttpPost]
    public async Task<IActionResult> CreateWorkOrder([FromBody] WorkOrderCreateDto dto)
    {
        string? planNo = null;
        if (dto.PlanId is > 0)
        {
            var plan = await _planRep.GetByIdAsync(dto.PlanId.Value);
            planNo = plan?.PlanNo;
        }

        var item = new AdoWorkOrder
        {
            WorkOrderNo = $"WO{DateTime.Now:yyyyMMddHHmmss}{Random.Shared.Next(1000, 9999)}",
            PlanId = dto.PlanId,
            PlanNo = planNo,
            Product = dto.Product,
            Quantity = dto.Quantity,
            WorkCenter = dto.WorkCenter,
            Team = dto.Team,
            Owner = dto.Owner,
            StartDate = dto.StartDate,
            PlanEndDate = dto.PlanEndDate,
            Priority = dto.Priority,
            Remark = dto.Remark,
            Status = "待生产",
            CreatedTime = DateTime.Now
        };

        await _workOrderRep.AsInsertable(item).ExecuteReturnEntityAsync();

        return Ok(new { id = item.Id, message = "创建成功" });
    }

    [HttpPut("{id:long}")]
    public async Task<IActionResult> UpdateWorkOrder(long id, [FromBody] WorkOrderUpdateDto dto)
    {
        var item = await _workOrderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        item.Product = dto.Product;
        item.Quantity = dto.Quantity;
        item.CompletedQuantity = dto.CompletedQuantity;
        item.WorkCenter = dto.WorkCenter;
        item.Team = dto.Team;
        item.Owner = dto.Owner;
        item.StartDate = dto.StartDate;
        item.PlanEndDate = dto.PlanEndDate;
        item.Priority = dto.Priority;
        item.Remark = dto.Remark;
        item.Status = dto.Status;
        item.UpdatedTime = DateTime.Now;

        if (dto.Status == "已完工" && item.ActualEndDate == null)
            item.ActualEndDate = DateTime.Now;

        await _workOrderRep.AsUpdateable(item).ExecuteCommandAsync();

        return Ok(new { message = "更新成功" });
    }

    [HttpDelete("{id:long}")]
    public async Task<IActionResult> DeleteWorkOrder(long id)
    {
        var item = await _workOrderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        await _workOrderRep.DeleteAsync(item);

        return Ok(new { message = "删除成功" });
    }

    [HttpPost("{id:long}/complete")]
    public async Task<IActionResult> CompleteWorkOrder(long id, [FromBody] object? _)
    {
        var item = await _workOrderRep.GetByIdAsync(id);
        if (item == null)
            return NotFound();

        item.Status = "已完工";
        item.ActualEndDate = DateTime.Now;
        item.UpdatedTime = DateTime.Now;

        await _workOrderRep.AsUpdateable(item).ExecuteCommandAsync();

        return Ok(new { message = "完工成功" });
    }
}