using Lada.Framework.DTO;
using Lada.Framework.DTO.SmartTable;
using Lada.Framework.Infrastructures.Helpers;
using Ladaer.BackEnd.Infrastructures.DTO.Models.Crm;
using Ladaer.BackEnd.Infrastructures.Services.Crm;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Crm
{
    /// <summary>
    /// CallLog Controller - Quản lý cuộc gọi tổng đài
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class CallLogController : ControllerBase
    {
        private readonly ICallLogService _callLogService;

        public CallLogController(ICallLogService callLogService)
        {
            _callLogService = callLogService;
        }

        /// <summary>
        /// Tìm kiếm call log
        /// </summary>
        /// <param name="param">Các tham số tìm kiếm</param>
        /// <returns>Kết quả tìm kiếm</returns>
        [HttpPost("Search")]
        [Authorize(Roles = "CallLog.Search")]
        public async Task<IActionResult> Search([FromBody] SmartTableParam param)
        {
            var callLogs = await _callLogService.Search(param);
            return Ok(callLogs);
        }

        /// <summary>
        /// Lấy thông tin chi tiết call log theo ID
        /// </summary>
        /// <param name="id">ID của call log</param>
        /// <returns>Thông tin chi tiết call log</returns>
        [HttpGet("GetById/{id}")]
        [Authorize(Roles = "CallLog.GetById")]
        public async Task<IActionResult> GetById(int id)
        {
            var callLog = await _callLogService.GetById(id);
            if (callLog == null)
            {
                return NotFound("Không tìm thấy call log");
            }
            return Ok(callLog);
        }

        /// <summary>
        /// Tạo hoặc cập nhật call log
        /// </summary>
        /// <param name="model">Model chứa thông tin call log cần tạo/cập nhật</param>
        /// <returns>Kết quả của hoạt động tạo/cập nhật call log</returns>
        [HttpPost("CreateOrUpdate")]
        [Authorize(Roles = "CallLog.CreateOrUpdate")]
        public async Task<IActionResult> CreateOrUpdate([FromBody] CallLogModel model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var currentUser = User.GetCurrentUser();
            model.UpdatedBy = currentUser.UserId;
            model.UpdatedByUserName = currentUser.UserName;

            if (model.UpdatedBy <= 0 || string.IsNullOrEmpty(model.UpdatedByUserName))
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _callLogService.CreateOrUpdate(model);
            return Ok(result);
        }

        /// <summary>
        /// Tạo call log mới
        /// </summary>
        /// <param name="model">Model chứa thông tin call log cần tạo</param>
        /// <returns>Kết quả của hoạt động tạo call log</returns>
        [HttpPost("Create")]
        [Authorize(Roles = "CallLog.Create")]
        public async Task<IActionResult> Create([FromBody] CallLogModel model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var currentUser = User.GetCurrentUser();
            model.UpdatedBy = currentUser.UserId;
            model.UpdatedByUserName = currentUser.UserName;
            model.CreatedBy = currentUser.UserId;
            model.CreatedByUserName = currentUser.UserName;

            if (model.UpdatedBy <= 0 || string.IsNullOrEmpty(model.UpdatedByUserName))
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _callLogService.Create(model);
            return Ok(result);
        }

        /// <summary>
        /// Xóa call log
        /// </summary>
        /// <param name="id">ID của call log cần xóa</param>
        /// <returns>Kết quả của hoạt động xóa</returns>
        [HttpDelete("Delete/{id}")]
        [Authorize(Roles = "CallLog.Delete")]
        public async Task<IActionResult> Delete(int id)
        {
            var currentUser = User.GetCurrentUser();
            if (currentUser.UserId <= 0 || string.IsNullOrEmpty(currentUser.UserName))
            {
                return BadRequest("Không xác định được người dùng");
            }

            var result = await _callLogService.Delete(id);
            return Ok(result);
        }

        /// <summary>
        /// Cập nhật trạng thái Lead cho call log
        /// </summary>
        /// <param name="id">ID của call log</param>
        /// <param name="model">Model chứa thông tin trạng thái mới</param>
        /// <returns>Kết quả của hoạt động cập nhật</returns>
        [HttpPut("UpdateLeadStatus/{id}")]
        [Authorize(Roles = "CallLog.UpdateLeadStatus")]
        public async Task<IActionResult> UpdateLeadStatus(int id, [FromBody] CallLogModel model)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var currentUser = User.GetCurrentUser();
            if (currentUser.UserId <= 0 || string.IsNullOrEmpty(currentUser.UserName))
            {
                return BadRequest("Không xác định được người dùng");
            }

            // Lấy call log hiện tại
            var existingCallLog = await _callLogService.GetById(id);
            if (existingCallLog == null)
            {
                return NotFound("Không tìm thấy call log");
            }

            // Cập nhật chỉ trạng thái Lead và nội dung
            existingCallLog.LeadStatus = model.LeadStatus;
            existingCallLog.StatusContent = model.StatusContent;
            existingCallLog.UpdatedBy = currentUser.UserId;
            existingCallLog.UpdatedByUserName = currentUser.UserName;

            var result = await _callLogService.CreateOrUpdate(existingCallLog);
            return Ok(result);
        }

        /// <summary>
        /// Lấy danh sách call log theo số điện thoại
        /// </summary>
        /// <param name="phoneNumber">Số điện thoại</param>
        /// <returns>Danh sách call log</returns>
        [HttpGet("GetByPhoneNumber/{phoneNumber}")]
        [Authorize(Roles = "CallLog.GetByPhoneNumber")]
        public async Task<IActionResult> GetByPhoneNumber(string phoneNumber)
        {
            if (string.IsNullOrEmpty(phoneNumber))
            {
                return BadRequest("Số điện thoại không được để trống");
            }

            var param = new SmartTableParam
            {
                Search = new Lada.Framework.DTO.SmartTable.Search
                {
                    PredicateObject = Newtonsoft.Json.Linq.JObject.FromObject(new { FromNo = phoneNumber })
                },
                Pagination = new Lada.Framework.DTO.SmartTable.Pagination
                {
                    PageIndex = 1,
                    PageSize = 50
                }
            };

            var result = await _callLogService.Search(param);
            return Ok(result);
        }

        /// <summary>
        /// Thống kê call log theo khoảng thời gian
        /// </summary>
        /// <param name="startDate">Ngày bắt đầu</param>
        /// <param name="endDate">Ngày kết thúc</param>
        /// <returns>Thống kê call log</returns>
        [HttpGet("Statistics")]
        [Authorize(Roles = "CallLog.Statistics")]
        public async Task<IActionResult> GetStatistics([FromQuery] DateTime? startDate, [FromQuery] DateTime? endDate)
        {
            var param = new SmartTableParam
            {
                Search = new Lada.Framework.DTO.SmartTable.Search
                {
                    PredicateObject = Newtonsoft.Json.Linq.JObject.FromObject(new { TimeStart = startDate, TimeEnd = endDate })
                },
                Pagination = new Lada.Framework.DTO.SmartTable.Pagination
                {
                    PageIndex = 1,
                    PageSize = int.MaxValue
                }
            };

            var result = await _callLogService.Search(param);

            // Tính toán thống kê
            var statistics = new
            {
                TotalCalls = result.TotalRecord,
                TotalDuration = result.Items.Sum(x =>
                {
                    if (TimeSpan.TryParse(x.Duration, out var duration))
                        return duration.TotalMinutes;
                    return 0;
                }),
                TotalCost = result.Items.Sum(x => x.BillCost ?? 0),
                CallsByStatus = result.Items.GroupBy(x => x.LeadStatus)
                    .Select(g => new { Status = g.Key.ToString(), Count = g.Count() }),
                CallsByType = result.Items.GroupBy(x => x.CallType)
                    .Select(g => new { Type = g.Key, Count = g.Count() })
            };

            return Ok(statistics);
        }
    }
}
