using DamageAssesment.Api.Documents.Db;
using DamageAssesment.Api.Documents.Interfaces;
using DamageAssesment.Api.Documents.Models;
using DamageAssesment.Api.Documents.Providers;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace DamageAssesment.Api.Documents.Controllers
{
    [Route("api")]
    [ApiController]
    public class DocumentsController : ControllerBase
    {
        private readonly IDocumentsProvider documentsProvider;
        private readonly IUploadService uploadService;

        public DocumentsController(IDocumentsProvider documentsProvider,IUploadService uploadService)
        {

            this.documentsProvider = documentsProvider;
            this.uploadService = uploadService; 

        }

        /// <summary>
        /// Get all documnets.
        /// </summary>
        [HttpGet("{language}/{LinkType}/documents")]
        public async Task<IActionResult> GetDocumentsbyFormsandLanguageAsync(string language,string LinkType)
        {
            var result = await this.documentsProvider.GetDocumnetsByLinkAsync(language, LinkType);
            if (result.IsSuccess)
            {
                return Ok(result.documents);
            }
            return NoContent();
        }
        /// <summary>
        /// Get all documnets.
        /// </summary>
        [HttpGet("{LinkType}/documents")]
        public async Task<IActionResult> GetDocumentsbyFormAsync(string LinkType)
        {
            var result = await this.documentsProvider.GetDocumnetsByLinkAsync(null, LinkType);
            if (result.IsSuccess)
            {
                return Ok(result.documents);
            }
            return NoContent();
        }
        /// <summary>
        /// Get all documnets.
        /// </summary>
        [HttpGet("documents")]
        public async Task<IActionResult> GetDocumentsAsync()
        {
            var result = await this.documentsProvider.GetDocumnetsAsync();
            if (result.IsSuccess)
            {
                return Ok(result.documents);
            }
            return NoContent();
        }

        /// <summary>
        /// Get a documnet by id.
        /// </summary>
        [HttpGet("documents/{id}")]
        public async Task<IActionResult> GetDocumentAsync(int id)
        {
            var result = await this.documentsProvider.GetDocumentAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Document);
            }
            return NotFound();
        }
        /// <summary>
        /// Upload new document.
        /// </summary>
        [HttpPut("documents")]
        public async Task<IActionResult> UpdateDocument(DocumentInfo documentInfo)
        {
            if (documentInfo != null)
            {
                var dbdoc = await this.documentsProvider.GetDocumentAsync(documentInfo.Id);
                if (dbdoc.IsSuccess)
                {
                    Models.Document document = uploadService.UpdateDocuments(dbdoc.Document, documentInfo);
                    var result = await this.documentsProvider.UpdateDocumentAsync(document);
                    if (result.IsSuccess)
                    {
                        return Ok(result.Document);
                    }
                    return NoContent();
                }
                return NoContent();
            }
            return BadRequest(documentInfo);
        }
        /// <summary>
        /// update existing document.
        /// </summary>
        [HttpPost("documents")]
        public async Task<IActionResult> CreateDocument(DocumentInfo documentInfo)
        {
            try
            {
                if (documentInfo != null)
                {
                    var documents = await this.documentsProvider.GetDocumentCounter();
                    Models.Document document = uploadService.UploadDocument(documents.counter, documentInfo);
                    var result = await this.documentsProvider.PostDocumentAsync(document);
                    if (result.IsSuccess)
                    {
                        return Ok(result.Document);
                    }
                    return NoContent();
                }
                return BadRequest(documentInfo);
            }
            catch (Exception ex)
            {
                return BadRequest($"Internal server error: {ex}");
            }
        }
        /// <summary>
        /// Delete documnet by id.
        /// </summary>
        [HttpDelete("documents/{id}")]
        public async Task<IActionResult> DeleteDocument(int id)
        {
            // database soft delete
            var result = await this.documentsProvider.DeleteDocumentAsync(id);
            if (result.IsSuccess)
            {
                // deleting file from folder
                uploadService.Movefile(result.Document.Path);
                return Ok(result.Document);
            }
            return NotFound();
        }
        /// <summary>
        /// Get all document link type.
        /// </summary>
        [HttpGet("LinkTypes")]
        public async Task<IActionResult> GetLinkTypesAsync()
        {
            var result = await this.documentsProvider.GetLinkTypesAsync();
            if (result.IsSuccess)
            {
                return Ok(result.LinkTypes);
            }
            return NoContent();
        }
        /// <summary>
        /// Get a document link type by id.
        /// </summary>
        [HttpGet("LinkTypes/{id}")]
        public async Task<IActionResult> GetLinkTypeAsync(int id)
        {
            var result = await this.documentsProvider.GetLinkTypeAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.LinkType);
            }
            return NotFound();
        }
        /// <summary>
        /// Update a existing document link type.
        /// </summary>
        [HttpPut("LinkTypes")]
        public async Task<IActionResult> UpdateLinkType(Models.LinkType linkType)
        {
            if (linkType != null)
            {
                var result = await this.documentsProvider.UpdateLinkTypeAsync(linkType);
                if (result.IsSuccess)
                {
                    return Ok(result.LinkType);
                }
                if (result.ErrorMessage == "Not Found")
                    return NotFound(result.ErrorMessage);

                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
        }
        /// <summary>
        /// Create a new document link type.
        /// </summary>
        [HttpPost("LinkTypes")]
        public async Task<IActionResult> CreateLinkType(Models.LinkType linkType)
        {
            if (linkType != null)
            {
                var result = await this.documentsProvider.PostLinkTypeAsync(linkType);
                if (result.IsSuccess)
                {
                    return Ok(result.LinkType);
                }
                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { id = linkType.Id }, linkType);
        }
        /// <summary>
        /// Delete a  existing document link type by id.
        /// </summary>
        [HttpDelete("LinkTypes/{id}")]
        public async Task<IActionResult> DeleteLinkType(int id)
        {
            var result = await this.documentsProvider.DeleteLinkTypeAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.LinkType);
            }
            return NotFound();
        }


    }
}