using Lada.Framework.Data.Enums;
using Lada.Framework.DTO.Models.Media;
using Lada.Framework.Infrastructures.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Ladaer.BackEnd.Controllers.Medias
{
    /// <summary>
    /// Controller demo cho New Media Services
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    [Authorize]
    public class NewMediaController : ControllerBase
    {
        private readonly IUnifiedMediaService _unifiedMediaService;

        public NewMediaController(IUnifiedMediaService unifiedMediaService)
        {
            _unifiedMediaService = unifiedMediaService;
        }

        #region Basic Image Processing

        /// <summary>
        /// Upload ảnh đơn giản (không lưu database)
        /// </summary>
        /// <param name="file">File ảnh</param>
        /// <param name="imageType">Loại ảnh (avatar, product, general, etc.)</param>
        /// <returns>URL ảnh đã xử lý</returns>
        [HttpPost("upload-image")]
        [Authorize(Roles = "NewMedia.UploadImage")]
        public async Task<IActionResult> UploadImage(IFormFile file, [FromForm] string imageType = "general")
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("Không có file được upload");
                }

                // Convert string to ImageType enum
                var imgType = Enum.TryParse<ImageType>(imageType, true, out var parsedType)
                    ? parsedType
                    : ImageType.General;

                var result = await _unifiedMediaService.ProcessImageAsync(file, imgType);

                if (result.Result == Lada.Framework.DTO.Result.Success)
                {
                    return Ok(new
                    {
                        success = true,
                        message = "Upload thành công",
                        data = new
                        {
                            url = result.Url,
                            systemPath = result.SystemPath,
                            fileSize = result.FileSize
                        }
                    });
                }

                return BadRequest(new
                {
                    success = false,
                    message = result.Message
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        /// <summary>
        /// Upload nhiều ảnh cùng lúc
        /// </summary>
        /// <param name="files">Danh sách file ảnh</param>
        /// <param name="imageType">Loại ảnh</param>
        /// <returns>Danh sách kết quả</returns>
        [HttpPost("upload-multiple-images")]
        [Authorize(Roles = "NewMedia.UploadMultipleImages")]
        public async Task<IActionResult> UploadMultipleImages(List<IFormFile> files, [FromForm] string imageType = "general")
        {
            try
            {
                if (files == null || !files.Any())
                {
                    return BadRequest("Không có file được upload");
                }

                var imgType = Enum.TryParse<ImageType>(imageType, true, out var parsedType)
                    ? parsedType
                    : ImageType.General;

                var results = await _unifiedMediaService.ProcessMultipleImagesAsync(files, imgType);

                return Ok(new
                {
                    success = true,
                    message = $"Đã xử lý {results.Count} ảnh",
                    data = results.Select(r => new
                    {
                        url = r.Url,
                        systemPath = r.SystemPath,
                        success = r.Result == Lada.Framework.DTO.Result.Success,
                        message = r.Message
                    })
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        #endregion

        #region Video Processing

        /// <summary>
        /// Upload video đơn giản
        /// </summary>
        /// <param name="file">File video</param>
        /// <param name="videoType">Loại video</param>
        /// <returns>URL video đã xử lý</returns>
        [HttpPost("upload-video")]
        [Authorize(Roles = "NewMedia.UploadVideo")]
        public async Task<IActionResult> UploadVideo(IFormFile file, [FromForm] string videoType = "general")
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("Không có file được upload");
                }

                // Validate video trước
                var isValid = await _unifiedMediaService.ValidateVideoAsync(file);
                if (!isValid)
                {
                    return BadRequest("File không phải video hợp lệ");
                }

                var vidType = Enum.TryParse<VideoType>(videoType, true, out var parsedType)
                    ? parsedType
                    : VideoType.General;

                var result = await _unifiedMediaService.ProcessVideoAsync(file, vidType);

                if (result.Result == Lada.Framework.DTO.Result.Success)
                {
                    return Ok(new
                    {
                        success = true,
                        message = "Upload video thành công",
                        data = new
                        {
                            url = result.Url,
                            systemPath = result.SystemPath,
                            fileSize = result.FileSize
                        }
                    });
                }

                return BadRequest(new
                {
                    success = false,
                    message = result.Message
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        #endregion

        #region Auto-detect Media

        /// <summary>
        /// Upload media tự động detect loại (ảnh hoặc video)
        /// </summary>
        /// <param name="file">File media</param>
        /// <returns>Kết quả xử lý</returns>
        [HttpPost("upload-media")]
        [Authorize(Roles = "NewMedia.UploadMedia")]
        public async Task<IActionResult> UploadMedia(IFormFile file)
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("Không có file được upload");
                }

                // Tự động detect loại media
                var mediaType = await _unifiedMediaService.DetectAndValidateMediaTypeAsync(file);

                if (mediaType == null)
                {
                    return BadRequest("File không được hỗ trợ. Chỉ chấp nhận ảnh (JPG, PNG, WebP) hoặc video (MP4, AVI, MOV)");
                }

                if (mediaType == Lada.Framework.Infrastructures.Services.MediaType.Image)
                {
                    var result = await _unifiedMediaService.ProcessImageAsync(file, ImageType.General);
                    return Ok(new
                    {
                        success = true,
                        mediaType = "image",
                        data = new
                        {
                            url = result.Url,
                            systemPath = result.SystemPath
                        }
                    });
                }
                else
                {
                    var result = await _unifiedMediaService.ProcessVideoAsync(file, VideoType.General);
                    return Ok(new
                    {
                        success = true,
                        mediaType = "video",
                        data = new
                        {
                            url = result.Url,
                            systemPath = result.SystemPath
                        }
                    });
                }
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        #endregion

        #region Business Logic Examples

        /// <summary>
        /// Upload ảnh cho attendance (có lưu database)
        /// </summary>
        /// <param name="file">File ảnh</param>
        /// <param name="attendanceId">ID chấm công</param>
        /// <returns>Kết quả xử lý</returns>
        [HttpPost("attendance/{attendanceId}/upload-image")]
        [Authorize(Roles = "NewMedia.UploadAttendanceImage")]
        public async Task<IActionResult> UploadAttendanceImage(IFormFile file, int attendanceId)
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("Không có file được upload");
                }

                // Giả lập lấy thông tin user hiện tại
                var userId = 1; // GetCurrentUserId();
                var userName = "admin"; // GetCurrentUserName();

                var options = new ImageSaveOptions
                {
                    ImageType = ImageType.Attendance,
                    SaveToDatabase = true,
                    AttendanceId = attendanceId,
                    CreatedBy = userId,
                    CreatedByUserName = userName,
                    UpdatedBy = userId,
                    UpdatedByUserName = userName,
                    AltText = "Ảnh chấm công",
                    Caption = "Ảnh chấm công"
                };

                var result = await _unifiedMediaService.ProcessImageWithDatabaseAsync(file, options);

                if (result.Result == Lada.Framework.DTO.Result.Success)
                {
                    return Ok(new
                    {
                        success = true,
                        message = "Upload ảnh chấm công thành công",
                        data = new
                        {
                            url = result.Url,
                            mediaId = result.MediaId,
                            attendanceId = attendanceId
                        }
                    });
                }

                return BadRequest(new
                {
                    success = false,
                    message = result.Message
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        /// <summary>
        /// Upload ảnh cho truck activity
        /// </summary>
        /// <param name="file">File ảnh</param>
        /// <param name="truckActivityId">ID hoạt động xe</param>
        /// <returns>Kết quả xử lý</returns>
        [HttpPost("truck-activity/{truckActivityId}/upload-image")]
        [Authorize(Roles = "NewMedia.UploadTruckActivityImage")]
        public async Task<IActionResult> UploadTruckActivityImage(IFormFile file, int truckActivityId)
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("Không có file được upload");
                }

                var userId = 1; // GetCurrentUserId();
                var userName = "admin"; // GetCurrentUserName();

                var options = new ImageSaveOptions
                {
                    ImageType = ImageType.TruckActivity,
                    SaveToDatabase = true,
                    TruckActivityId = truckActivityId,
                    CreatedBy = userId,
                    CreatedByUserName = userName,
                    UpdatedBy = userId,
                    UpdatedByUserName = userName,
                    AltText = "Ảnh hoạt động xe",
                    Caption = "Ảnh hoạt động xe"
                };

                var result = await _unifiedMediaService.ProcessImageWithDatabaseAsync(file, options);

                return Ok(new
                {
                    success = result.Result == Lada.Framework.DTO.Result.Success,
                    message = result.Message,
                    data = result.Result == Lada.Framework.DTO.Result.Success ? new
                    {
                        url = result.Url,
                        mediaId = result.MediaId,
                        truckActivityId = truckActivityId
                    } : null
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        #endregion

        #region Utility Methods

        /// <summary>
        /// Validate file có phải ảnh hợp lệ không
        /// </summary>
        /// <param name="file">File cần kiểm tra</param>
        /// <returns>True nếu hợp lệ</returns>
        [HttpPost("validate-image")]
        [Authorize(Roles = "NewMedia.ValidateImage")]
        public async Task<IActionResult> ValidateImage(IFormFile file)
        {
            try
            {
                if (file == null || file.Length == 0)
                {
                    return BadRequest("Không có file được upload");
                }

                var isValid = await _unifiedMediaService.ValidateImageAsync(file);

                return Ok(new
                {
                    success = true,
                    isValid = isValid,
                    message = isValid ? "File ảnh hợp lệ" : "File không phải ảnh hợp lệ"
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        /// <summary>
        /// Convert SystemPath thành URL hiển thị
        /// </summary>
        /// <param name="systemPath">Đường dẫn hệ thống</param>
        /// <returns>URL hiển thị</returns>
        [HttpGet("get-url")]
        [Authorize(Roles = "NewMedia.GetUrlBySystemPath")]
        public async Task<IActionResult> GetUrlBySystemPath([FromQuery] string systemPath)
        {
            try
            {
                if (string.IsNullOrEmpty(systemPath))
                {
                    return BadRequest("SystemPath không được để trống");
                }

                var url = await _unifiedMediaService.GetUrlBySystemPathAsync(systemPath);

                return Ok(new
                {
                    success = true,
                    systemPath = systemPath,
                    url = url
                });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new
                {
                    success = false,
                    message = $"Lỗi server: {ex.Message}"
                });
            }
        }

        #endregion
    }
}
