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.Models;
using MisIngredientesVue.Core.Services;
using MisIngredientesVue.Core.Extensions;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Text;

namespace MisIngredientesVue.Controllers
{

    [Route("api/[controller]")]
    [ApiController]
    public class OrderTemplatesController : Controller
    {
        private readonly IOrderTemplatesService _orderTemplatesService;

        public OrderTemplatesController(IOrderTemplatesService orderTemplatesService)
        {
            _orderTemplatesService = orderTemplatesService;
        }

        [Route("{id}")]
        [HttpGet]
        public async Task<IActionResult> Get(int id)
        {
            if(User.Identity.IsClient())
                return Ok(await _orderTemplatesService.GetClientOrderTemplateById(User.Identity.GetTenantId(), id));

            return Ok(await _orderTemplatesService.GetOrderTemplateById(User.Identity.GetTenantId(), id));
        }

        //Este es para obtener la plantilla global de proveedor (sólo restaurantes)
        [Route("bysupplierid/{id}")]
        [HttpGet]
        public async Task<IActionResult> GetClientOrderTemplateBySupplierId(int id)
        {
            if (!User.Identity.IsClient())
                return BadRequest();

            return Ok(await _orderTemplatesService.GetClientOrderTemplateBySupplierId(User.Identity.GetTenantId(), id));
        }

        [AllowAnonymous]
        [Route("public/{id}")]
        [HttpGet]
        public async Task<IActionResult> GetByPublicId(string id)
        {
            if (string.IsNullOrEmpty(id)) return BadRequest();
            return Ok(await _orderTemplatesService.GetOrderTemplateByPublicId(id));
        }

        [HttpGet]
        public async Task<IActionResult> Get(int skip, int take, string sortBy, string sortOrder, string q)
        {
            if (User.Identity.IsClient())
            {
                var findAll = await _orderTemplatesService.GetClientTemplates(User.Identity.GetTenantId(), skip, take, sortBy, sortOrder, q);
                return Ok(new PagedResults<OrderTemplate>(findAll.Results, findAll.Total, skip, take));
            }
            else
            {
                var findAll = await _orderTemplatesService.GetTemplates(User.Identity.GetTenantId(), skip, take, sortBy, sortOrder, q);
                return Ok(new PagedResults<OrderTemplate>(findAll.Results, findAll.Total, skip, take));
            }
        }

        [Route("{id}/excel")]
        [HttpPost]
        public async Task<IActionResult> GetExcel(int id)
        {
            if (User.Identity.IsClient())
            {
                var memoryStream = await _orderTemplatesService.GetClientTemplateExcel(User.Identity.GetTenantId(), id);
                return File(memoryStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
            }
            else
            {
                var memoryStream = await _orderTemplatesService.GetTemplateExcel(User.Identity.GetTenantId(), id);
                return File(memoryStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
            }
        }

        [Route("public/{id}/excel")]
        [HttpPost]
        public async Task<IActionResult> GetPublicExcel(string id)
        {
            var memoryStream = await _orderTemplatesService.GetPublicTemplateExcel(id);
            return File(memoryStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        }

        [Route("{id}/send")]
        [HttpPost]
        public async Task<IActionResult> SendByEmail(int id, SendTemplateByEmailRequest request)
        {
            await _orderTemplatesService.SendByEmail(User.Identity.GetTenantId(), id, request.Recipients, request.EmailBody, User.Identity.GetSubscriptionLevel() == 0);
            return Ok();
        }

        [Route("{id}/branches")]
        [HttpGet]
        public async Task<IActionResult> GetBrandBranchesByTemplateId(int id)
        {
            if (User.Identity.IsClient())
                return Ok(await _orderTemplatesService.GetClientBranchesByTemplateId(User.Identity.GetTenantId(), id));

            return Ok(await _orderTemplatesService.GetBranchesByTemplateId(User.Identity.GetTenantId(), id));
        }

        [AllowAnonymous]
        [Route("public/{id}/branches")]
        [HttpGet]
        public async Task<IActionResult> GetBrandBranchesByPublicTemplateId(string id)
        {
            if (string.IsNullOrEmpty(id)) return BadRequest();
            return Ok(await _orderTemplatesService.GetBranchesByPublicTemplateId(id));
        }

        [HttpPost]
        public async Task<IActionResult> Post(OrderTemplate orderTemplate)
        {
            //TODO: Investigar
            if(User.Identity.IsClient())
                return Ok(await _orderTemplatesService.InsertClientOrderTemplate(User.Identity.GetTenantId(), User.Identity.GetUserId(), orderTemplate));
            else 
                return Ok(await _orderTemplatesService.InsertOrderTemplate(User.Identity.GetTenantId(), User.Identity.GetUserId(), orderTemplate));
        }

        [Route("{id}")]
        [HttpPut]
        public async Task<IActionResult> Put(int id, [FromBody]OrderTemplate orderTemplate)
        {
            if (id != orderTemplate.Id)
                return BadRequest();

            await _orderTemplatesService.UpdateOrderTemplate(User.Identity.GetTenantId(), User.Identity.GetUserId(), orderTemplate);
            
            return Ok();
        }

        [Route("generaltemplate")]
        [HttpPut]
        public async Task<IActionResult> UpdateGeneralTemplate([FromBody] OrderTemplate orderTemplate)
        {
            await _orderTemplatesService.UpdateGeneralOrderTemplate(User.Identity.GetTenantId(), User.Identity.GetUserId(), orderTemplate);
            return Ok();
        }

        [Route("{id}/metadata")]
        [HttpPut]
        public async Task<IActionResult> UpdateMetadata(int id, [FromBody] OrderTemplate orderTemplate)
        {
            if (id != orderTemplate.Id)
                return BadRequest();

            if (User.Identity.IsClient())
                await _orderTemplatesService.UpdateClientOrderTemplateMetadata(User.Identity.GetTenantId(), User.Identity.GetUserId(), orderTemplate);
            else
                await _orderTemplatesService.UpdateOrderTemplateMetadata(User.Identity.GetTenantId(), User.Identity.GetUserId(), orderTemplate);

            return Ok();
        }

        [Route("{id}")]
        [HttpPatch]
        public async Task<IActionResult> Patch(int id, [FromBody]JsonPatchDocument<OrderTemplate> changes)
        {
            await _orderTemplatesService.PatchOrderTemplate(User.Identity.GetTenantId(), User.Identity.GetUserId(), id, changes);
            return Ok();
        }

        [Route("delete")]
        [HttpPut]
        public async Task<IActionResult> Delete([FromBody]int[] ids) {

            await _orderTemplatesService.DeleteOrderTemplates(User.Identity.GetTenantId(), User.Identity.GetUserId(), ids);
            return Ok();
        }


    }

    public class DuplicateRequest
    {
        public string Name { get; set; }
    }

    public class SendTemplateByEmailRequest
    {
        public string[] Recipients { get; set; }
        public string EmailBody { get; set; }
    }
}