using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Serilog;
using LCU.Library.Internal.FileOperationsModels.Models;
using LCU.Library.Internal.Exceptions;
using LCU.Library.Internal.ApiResponse.Models;
using LCU.Api.Internal.FileOperations.Services.QueueServices;
using LCU.Api.Internal.FileOperations.Extensions;
using LCU.Api.Internal.FileOperations.Services;
using LCU.Api.Internal.FileOperations.Services.FileActionServices;
namespace LCU.Api.Internal.FileOperations.Controllers;

[Route("api/[controller]")]
[ApiController]
public class FileOperationsController : ControllerBase
{
    private readonly IQueueFileOperationsService _queueFileOperationsService;
    private readonly IActionService<MoveFileRequest> _moveFileService;
    private readonly IActionService<CopyFileRequest> _copyFileService;
    private readonly IActionService<DeleteFileRequest> _deleteFileService;
    private readonly IActionService<ModifyFileRequest> _modifyFileService;
    private readonly IActionService<RenameFileRequest> _renameFileService;
    private readonly IActionService<ZipDirectoryRequest> _zipDirectoryService;
    private readonly IActionService<UnzipFileRequest> _unzipFileService;
    private readonly IActionService<UnzipPasswordProtectedFileRequest> _unzipPasswordProtectedFileService;
    private readonly IActionService<CreateDirectoryRequest> _createDirectoryService;
    private readonly IActionService<RenameDirectoryRequest> _renameDirectoryService;
    private readonly IActionService<BulkOperationRequest<MoveFileRequest>> _bulkMoveFileService;
    private readonly IActionService<EncryptFileDataRequest> _encryptFileDataService;
    private readonly IActionService<DecryptFileDataRequest> _decryptFileDataService;
    private readonly IActionService<WriteFileRequest> _writeFileDataService;
    private readonly IActionService<DeleteDirectoryRequest> _deleteDirectoryService;
    private readonly IActionService<DeleteEmptyDirectoryRequest> _deleteEmptyDirectoryService;
    private readonly IDirectFileService _directFileService;

    public FileOperationsController(IQueueFileOperationsService fileOperationsService,
                                    IActionService<MoveFileRequest> moveFileService,
                                    IActionService<CopyFileRequest> copyFileService,
                                    IActionService<ModifyFileRequest> modifyFileService,
                                    IActionService<DeleteFileRequest> deleteFileService,
                                    IActionService<RenameFileRequest> renameFileService,
                                    IActionService<ZipDirectoryRequest> zipDirectoryService,
                                    IActionService<UnzipFileRequest> unzipFileService,
                                    IActionService<UnzipPasswordProtectedFileRequest> unzipPasswordProtectedFileService,
                                    IActionService<CreateDirectoryRequest> createDirectoryService,
                                    IActionService<RenameDirectoryRequest> renameDirectoryService,
                                    IActionService<BulkOperationRequest<MoveFileRequest>> bulkMoveFileService,
                                    IActionService<EncryptFileDataRequest> encryptFileDataService,
                                    IActionService<DecryptFileDataRequest> decryptFileDataService,
                                    IActionService<WriteFileRequest> writeFileDataService,
                                    IActionService<DeleteDirectoryRequest> deleteDirectoryService,
                                    IActionService<DeleteEmptyDirectoryRequest> deleteEmptyDirectoryService,
                                    IDirectFileService directFileService)
    {
        _queueFileOperationsService = fileOperationsService;
        _moveFileService = moveFileService;
        _copyFileService = copyFileService;
        _modifyFileService = modifyFileService; 
        _deleteFileService = deleteFileService;
        _renameFileService = renameFileService;
        _zipDirectoryService = zipDirectoryService;
        _unzipFileService = unzipFileService;
        _unzipPasswordProtectedFileService = unzipPasswordProtectedFileService;
        _createDirectoryService = createDirectoryService;
        _renameDirectoryService = renameDirectoryService;
        _bulkMoveFileService = bulkMoveFileService;
        _encryptFileDataService = encryptFileDataService;
        _decryptFileDataService = decryptFileDataService;
        _directFileService = directFileService;
        _writeFileDataService = writeFileDataService;
        _deleteDirectoryService = deleteDirectoryService;
        _deleteEmptyDirectoryService = deleteEmptyDirectoryService;
    }

    // Get api/{file}
    [HttpGet("{filename}")]
    [ProducesResponseType(200)]
    [ProducesResponseType(400)]
    public IActionResult GetFile([FromRoute] string filename)
    {
        if (string.IsNullOrWhiteSpace(filename))
        {
            return BadRequest("filename is required");
        }

        try
        {
            var result = _directFileService.GetFileBytes(filename);
            return new FileContentResult(result, "application/octet-stream");
        }
        catch (ArgumentException ae)
        {
            Log.Error(ae, $"Request for bad file path {filename}");
            return BadRequest("File path not found");
        }
        catch (Exception ex)
        {
            Log.Error(ex, $"Unexpected error retrieving file path {filename}");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    // POST api/MoveFile
    [HttpPost("MoveFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> MoveFile([FromBody] MoveFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Move, _moveFileService);
    }

    // POST api/CopyFile
    [HttpPost("CopyFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> CopyFile([FromBody] CopyFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Copy, _copyFileService);
    }

    // POST api/ModifyFile
    [HttpPost("ModifyFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> ModifyFile([FromBody] ModifyFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Modify, _modifyFileService);
    }

    // POST api/DeleteFile
    [HttpPost("DeleteFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> DeleteFile([FromBody] DeleteFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Delete, _deleteFileService);
    }

    // POST api/RenameFile
    [HttpPost("RenameFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> RenameFile([FromBody] RenameFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.Rename, _renameFileService);
    }

    // POST api/ZipDirectory
    [HttpPost("ZipDirectory")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> ZipDirectory([FromBody] ZipDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.ZipDirectory, _zipDirectoryService);
    }

    // POST api/UnzipFile
    [HttpPost("UnzipFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> UnzipFile([FromBody] UnzipFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.UnzipFile, _unzipFileService);
    } 
    
    // POST api/UnzipPasswordProtectedFile
    [HttpPost("UnzipPasswordProtectedFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> UnzipPasswordProtectedFile([FromBody] UnzipPasswordProtectedFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.UnzipPasswordProtectedFile, _unzipPasswordProtectedFileService);
    }

    // POST api/CreateDirectory
    [HttpPost("CreateDirectory")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> CreateDirectory([FromBody] CreateDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.CreateDirectory, _createDirectoryService);
    }

    // POST api/RenameDirectory
    [HttpPost("RenameDirectory")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> RenameDirectory([FromBody] RenameDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.RenameDirectory, _renameDirectoryService);
    }

    // POST api/BulkMoveFile
    [HttpPost("BulkMoveFile")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> BulkMoveFile([FromBody] BulkOperationRequest<MoveFileRequest> request)
    {
        return await HandleRequestResponse(request, FileOperationType.BulkMoveFile, _bulkMoveFileService);
    }

    // POST api/EncryptFileData
    [HttpPost("EncryptFileData")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> EncryptFileData([FromBody] EncryptFileDataRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.EncryptFileData, _encryptFileDataService);
    }

    // POST api/DecryptFileData
    [HttpPost("DecryptFileData")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> DecryptFileData([FromBody] DecryptFileDataRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.DecryptFileData, _decryptFileDataService);
    }

    // POST api/WriteFileData
    [HttpPost("WriteFileData")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> WriteFileData([FromBody] WriteFileRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.WriteFile, _writeFileDataService);
    }

    [HttpPost("DeleteDirectory")]
    [ProducesResponseType(201)]
    [ProducesResponseType(typeof(List<string>), 400)]
    [ProducesResponseType(500)]
    public async Task<IActionResult> DeleteDirectory([FromBody] DeleteDirectoryRequest request)
    {
        return await HandleRequestResponse(request, FileOperationType.DeleteDirectory, _deleteDirectoryService);
    }

	[HttpPost("DeleteEmptyDirectory")]
	[ProducesResponseType(201)]
	[ProducesResponseType(typeof(List<string>), 400)]
	[ProducesResponseType(500)]
	public async Task<IActionResult> DeleteEmptyDirectory([FromBody] DeleteEmptyDirectoryRequest request)
	{
		return await HandleRequestResponse(request, FileOperationType.DeleteEmptyDirectory, _deleteEmptyDirectoryService);
	}

	public async Task<IActionResult> HandleRequestResponse<TRequest>(TRequest originalRequest, FileOperationType operationType, IActionService<TRequest> service) where TRequest : ReturnResponse
    {
        try
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState.GetErrorMessages());
            }

            var validateResponse = service.PreQueueValidation(originalRequest);
            if (!validateResponse.IsSuccessful)
            {
                return BadRequest($"Request is invalid. Response: {String.Join("\n ", validateResponse.MessageStack.ToArray())}");
            }

            await _queueFileOperationsService.QueueFileOperations(originalRequest, operationType);
            return Ok();
        }
        catch (ServiceException)
        {
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Unexpected Exception");
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }
}