using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Dapper;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.JsonPatch;
using Microsoft.AspNetCore.Mvc;
using MisIngredientesVue.Core.Extensions;
using MisIngredientesVue.Core.Models;
using MisIngredientesVue.Core.Services;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace MisIngredientesVue.Controllers
{

    [Route("api/[controller]")]
    [ApiController]
    public class ClientsController : Controller
    {
        private readonly IClientsService _clientsService;

        public ClientsController(IClientsService clientsService)
        {
            _clientsService = clientsService;
        }

        [Route("all")]
        [HttpGet]
        public async Task<IActionResult> GetAll()
        {
            if (User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetAllClients(User.Identity.GetTenantId()));
        }

        [Route("{id}")]
        [HttpGet]
        public async Task<IActionResult> Get(int id)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetClient(User.Identity.GetTenantId(), id));
        }

        [HttpGet]
        public async Task<IActionResult> Get(int skip, int take, string sortBy, string sortOrder, string q, int includeDeleted = 0)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            var findAll = await _clientsService.GetClients(User.Identity.GetTenantId(), skip, take, sortBy, sortOrder, q, includeDeleted);
            return Ok(new PagedResults<Client>(findAll.Results, findAll.Total, skip, take));
        }

        [Route("distinct")]
        [HttpGet]
        public async Task<IActionResult> GetDistinctClients()
        {
            if (User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetDistinctClients(User.Identity.GetTenantId()));
        }

        [Route("quicksearch")]
        [HttpGet]
        public async Task<IActionResult> GetClients(string q)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.QuickSearchClients(User.Identity.GetTenantId(), q));
        }

        [Route("{id}")]
        [HttpPatch]
        public async Task<IActionResult> Patch(int id, [FromBody]JsonPatchDocument<Client> changes)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            await _clientsService.PatchClient(User.Identity.GetTenantId(), User.Identity.GetUserId(), id, changes);
            return Ok(); 
        }

        [HttpGet]
        [Route("muns")]
        public dynamic GetStates(string state, string term)
        {
            if (term == "ALL")
            {
                return from m in Municipios.MUNICIPIOS[state]
                       select m;
            }

            var muns = Municipios.MUNICIPIOS[state].Where(m =>
                m.IndexOf(term, StringComparison.OrdinalIgnoreCase) >= 0).Take(7);

            return from m in muns
                   select new
                   { name = m, id = m };
        }

        [Route("{id}/brands")]
        [HttpGet]
        public async Task<IActionResult> GetBrands(int id)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetBrands(User.Identity.GetTenantId(), id));
        }

        [Route("branchesbybrandids")]
        [HttpPost]
        public async Task<IActionResult> GetBranchesByBrandIds(GetBranchesByBrandIdsRequest request)
        {
            if (!User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetBranchesByBrandIds(User.Identity.GetTenantId(), request.BrandIds));
        }

        [Route("brands")]
        [HttpGet]
        public async Task<IActionResult> GetCurrentBrands()
        {
            if (!User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetBrands(User.Identity.GetTenantId()));
        }

        [Route("branches")]
        [HttpGet]
        public async Task<IActionResult> GetCurrentBranches()
        {
            if (!User.Identity.IsClient())
                return BadRequest();
            
            return Ok(await _clientsService.GetBranches(User.Identity.GetTenantId()));
        }

        [Route("rfcs")]
        [HttpGet]
        public async Task<IActionResult> GetCurrentRfcs()
        {
            if (!User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetRfcs(User.Identity.GetTenantId()));
        }

        [Route("brandsandbranches")]
        [HttpGet]
        public async Task<IActionResult> GetCurrentBrandsAndBranches()
        {
            if (!User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.GetBrandsAndBranches(User.Identity.GetTenantId()));
        }

        [Route("{id}/brands/{brandId}/branches")]
        [HttpGet]
        public async Task<IActionResult> GetBrandBranches(int id, int brandId)
        {
            return Ok(await _clientsService.GetBrandBranches(User.Identity.GetTenantId(), id, brandId));
        }

        [Route("branches/distinct")]
        [HttpGet]
        public async Task<IActionResult> GetBranches()
        {
            return Ok(await _clientsService.GetDistinctBranches(User.Identity.GetTenantId()));
        }

        [Route("generaldata")]
        [HttpGet]
        public async Task<IActionResult> GetGeneralData()
        {
            if (!User.Identity.IsClient())
                return BadRequest();
            
            return Ok(await _clientsService.GetGeneralData(User.Identity.GetTenantId()));
        }

        [Route("productcount")]
        [HttpGet]
        public async Task<IActionResult> GetProductCount([FromBody] int[] ids)
        {
            //Este método es para determinar cuantos productos pueden usarse en una plantilla
            if (!User.Identity.IsClient())
                return BadRequest();
            
            return Ok(await _clientsService.GetProductCount(User.Identity.GetTenantId(), ids));
        }

        [Route("generaldata")]
        [HttpPut]
        public async Task<IActionResult> UpdateGeneralData([FromForm]ClientGeneralData request)
        {

            if (!User.Identity.IsClient())
                return BadRequest();

            if (request.Image == null || request.Image.Length == 0)
            {
                await _clientsService.UpdateGeneralData(User.Identity.GetTenantId(), request);
                return Ok(new { imgSrc = "" });
            }
            else
            {
                if (request.Image.Length > 512000) return BadRequest("La imagen es muy grande");

                using (var file = request.Image.OpenReadStream())
                {
                    using (var ms = new MemoryStream())
                    {
                        file.CopyTo(ms);
                        var imgSrc = await _clientsService.UpdateGeneralData(User.Identity.GetTenantId(), request, ms.ToArray());
                        return Ok(new { imgSrc });
                    }
                }
            }
        }

        [HttpPost]
        public async Task<IActionResult> Post(Client client)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            return Ok(await _clientsService.InsertClient(User.Identity.GetTenantId(), User.Identity.GetUserId(), client));
        }

        [Route("brands")]
        [HttpPost]
        public async Task<IActionResult> AddBrandToCurrentClient([FromBody] ClientBrand brand)
        {
            if (!User.Identity.IsClient())
                return BadRequest();
           
            await _clientsService.AddBrandToCurrentClient(User.Identity.GetTenantId(), User.Identity.GetUserId(), brand);
            return Ok();
        }

        [Route("brands/{id}")]
        [HttpPut]
        public async Task<IActionResult> EditBrandFromCurrentClient(int id, [FromBody] ClientBrand brand)
        {
            if (!User.Identity.IsClient())
                return BadRequest();
           
            await _clientsService.EditBrandFromCurrentClient(User.Identity.GetTenantId(), id, User.Identity.GetUserId(), brand);
            return Ok();
        }

        [Route("brands/{id}/branches")]
        [HttpPost]
        public async Task<IActionResult> AddBranchToBrand(int id, [FromBody]ClientBranch branch)
        {
            if (!User.Identity.IsClient())
                return BadRequest();
           
            await _clientsService.AddBranchToBrand(User.Identity.GetTenantId(), id, User.Identity.GetUserId(), branch);
            return Ok();
        }

        [Route("brands/{brandId}/branches/{id}")]
        [HttpPut]
        public async Task<IActionResult> EditBranchInBrand(int brandId, int id, [FromBody] ClientBranch branch)
        {
            if (!User.Identity.IsClient())
                return BadRequest();
            
            await _clientsService.EditBranchFromBrand(User.Identity.GetTenantId(), brandId, id, User.Identity.GetUserId(), branch);
            return Ok();
        }

        [Route("rfcs")]
        [HttpPost]
        public async Task<IActionResult> AddRfcToCurrentClient([FromBody] ClientTaxPayer rfc)
        {
            if (!User.Identity.IsClient())
                return BadRequest();

            var newRfc = await _clientsService.AddRfc(User.Identity.GetTenantId(), User.Identity.GetUserId(), rfc);
            return Ok(newRfc);
        }

        [Route("rfcs/{id}")]
        [HttpPut]
        public async Task<IActionResult> EditRfcOfCurrentClient(int id, [FromBody] ClientTaxPayer rfc)
        {
            if (!User.Identity.IsClient())
                return BadRequest();
            
            await _clientsService.EditRfc(User.Identity.GetTenantId(), id, User.Identity.GetUserId(), rfc);
            return Ok();
        }

        [Route("{id}")]
        [HttpPut]
        public async Task<IActionResult> Put(int id, Client client)
        {
            if (User.Identity.IsClient())
                return BadRequest();

            if (id != client.Id)
                return BadRequest();

            await _clientsService.UpdateClient(User.Identity.GetTenantId(), User.Identity.GetUserId(), client);
            return Ok();
        }

        [Route("delete")]
        [HttpPut]
        public async Task<IActionResult> Delete([FromBody]int[] clients) 
        {
            if (User.Identity.IsClient())
                return BadRequest();

            await _clientsService.DeleteClients(User.Identity.GetTenantId(), User.Identity.GetUserId(), clients);
            return Ok();
        }
    }

    public class GetBranchesByBrandIdsRequest
    {
        public int[] BrandIds { get; set; }
    }
}