using AipGateway.AIP;
using AipGateway.API.Application;
using AipGateway.API.Application.Interfaces.Services;
using AipGateway.API.Domain.Models.Request;
using AipGateway.API.Domain.Models.Response;
using AipGateway.API.Services;
using AipGateway.API.Services.Interfaces;
using Azure.Core;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Serilog;
using Swashbuckle.AspNetCore.Annotations;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.IO;

namespace AipGateway.API.Controllers
{
    [ApiController]
    [Route("/api/v1/file")]
    [Produces("application/json")]
    public class ApiFileController : BaseController
    {
        private readonly ILogger<ApiFileController> _log;
        private readonly IApiFileService _service;
        private readonly IApiAuthService _authService;

        public ApiFileController(ILogger<ApiFileController> log, IApiAuthService authService, IApiFileService apiFileService)
        {
            _log = log;
            _authService = authService;
            _service = apiFileService;
        }

        [HttpPost("info")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseInfo>))]
        public async Task<IResult> GetFileInfo([FromBody] RequestFileInfo req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_INFO, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_INFO);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.GetInfo(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }

        [HttpPost("set-label")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> SetFileLabel([FromBody] RequestFileSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABEL, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABEL);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.SetLabel(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }
        
        [HttpPost("set-labels")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<List<ResponseFile>>))]
        public async Task<IResult> SetFileLabels([FromBody] RequestMultiFileSet req)
        {
            //await _service.SetAipFileLabels(req);
            //return Results.Ok();

#if true
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                int jobs = req.files.Count;
                List<ResponseFile> result = new List<ResponseFile>();
                var tasks = new List<Task<ResponseFile>>();
                foreach (var obj in req.files)
                {
                    RequestFileSet reqSet = new RequestFileSet
                    {
                        apiKey = req.apiKey,
                        email = req.email,
                        decryptKey = req.decryptKey,
                        aipGuid = req.aipGuid,
                        comment = req.comment,
                        file = new RequestFile
                        {
                            dispFileName = obj.dispFileName,
                            realFileName = obj.realFileName,
                        }
                    };

                    tasks.Add(_service.SetLabel(reqSet));
                }
                await Task.WhenAll(tasks);
                foreach (var task in tasks)
                {
                    result.Add(task.Result);
                }
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

                return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = result,
                });
            });
#endif
#if false
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABELS, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABELS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }

                var result = await _service.SetLabels(req);
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

                return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = result,
                });
            });
#endif
        }

        [HttpPost("delete-label")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> DelFileLabel([FromBody] RequestFileDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_LABEL, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_LABEL);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DelLabel(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }

        [HttpPost("delete-labels")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> DelFileLabels([FromBody] RequestMultiFileDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                _log.LogInformation("*** Start DelFileLabels: {0} EA.", req.files.Count);
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_LABELS, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_LABELS);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                int ii = 0;
                int jobs = req.files.Count;
                List<ResponseFile> result = new List<ResponseFile>();
                var tasks = new Task<ResponseFile>[jobs];
                foreach (var obj in req.files)
                {
                    RequestFileDel reqSet = new RequestFileDel
                    {
                        apiKey = req.apiKey,
                        email = req.email,
                        decryptKey = req.decryptKey,
                        comment = req.comment,
                        file = new RequestFile
                        {
                            dispFileName = obj.dispFileName,
                            realFileName = obj.realFileName,
                        }
                    };

                    tasks[ii++] = _service.DelLabel(reqSet);
                }
                await Task.WhenAll(tasks);
                foreach (var task in tasks)
                {
                    result.Add(task.Result);
                }
                HttpContext.Items[GlobalConstants.API_RESULT_CODE] = 0;
                HttpContext.Items[GlobalConstants.API_RESULT_MESSAGE] = GlobalConstants.API_RESULT_SUCCESS;

                sw.Stop();
                _log.LogInformation("*** ...End SetFileLabels: {0} EA. {1,6} ms.", req.files.Count, sw.ElapsedMilliseconds.ToString("#,##0"));
                return Results.Ok(new ApiResponseModel<List<ResponseFile>>()
                {
                    success = true,
                    errorCode = 0,
                    errorMessage = GlobalConstants.API_RESULT_SUCCESS,
                    result = result,
                });
            });
        }

        [HttpPost("set-protection")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> SetFileProtection([FromBody] RequestFileSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_PROTECTION, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_PROTECTION);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.SetProtection(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }

        [HttpPost("delete-protection")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> DelFileProtection([FromBody] RequestFileDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_PROTECTIN, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_PROTECTIN);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DelProtection(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }


        [HttpPost("set-label-protection")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> SetFileLabelProtection([FromBody] RequestFileAllSet req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_SET_LABEL_PROTECTION, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_SET_LABEL_PROTECTION);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.SetLabelProtection(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }

        [HttpPost("delete-label-protection")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> DelFileLabelProtection([FromBody] RequestFileDel req)
        {
            return await CreateResponseAsync(async () =>
            {
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DELETE_LABEL_PROTECTION, req.apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DELETE_LABEL_PROTECTION);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DelLabelProtection(req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }

        [HttpPost("encrypt")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> EncryptFile([Required] IFormFile file, [Required] string apiKey, [Required] string email)
        {
            return await CreateResponseAsync(async () =>
            {
                RequestBase req = new RequestBase
                {
                    apiKey = apiKey,
                    email = email,
                    decryptKey = string.Empty,
                    apiGuid = string.Empty
                };
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_ENCRYPT, apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_ENCRYPT);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.EncryptFile(file, req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }
        [HttpPost("decrypt")]
        [SwaggerResponse(200, type: typeof(ApiResponseModel<ResponseFile>))]
        public async Task<IResult> DecryptFile([Required] IFormFile file, [Required] string apiKey, [Required] string email)
        {
            return await CreateResponseAsync(async () =>
            {
                RequestBase req = new RequestBase
                {
                    apiKey = apiKey,
                    email = email,
                    decryptKey = string.Empty,
                    apiGuid = string.Empty
                };
                GlobalConstants.SetAuthorization(HttpContext, GlobalConstants.API_FILE_DECRYPT, apiKey, req);
                HttpContext.Items[GlobalConstants.API_REQUEST] = (RequestBase)req;
                int authError = _authService.CheckApiKeyValidation(HttpContext, req.apiKey, GlobalConstants.API_FILE_DECRYPT);
                if (authError != 0)
                {
                    throw ResponseApiKeyValidationError(HttpContext, authError);
                }
                var response = await _service.DecryptFile(file, req);
                return Results.Ok(ResponseSuccess(HttpContext, response));
            });
        }
    }
}