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 DeliveryRoutesController : Controller
    {
        private readonly IDeliveryRoutesService _deliveryRoutesService;

        public DeliveryRoutesController(IDeliveryRoutesService deliveryRoutesService)
        {
            _deliveryRoutesService = deliveryRoutesService;
        }

        [Route("{year}/{month}/{day}")]
        [HttpGet]
        public async Task<IActionResult> GetRoutesForDay(int year, int month, int day)
        {
            return Ok(await _deliveryRoutesService.GetRoute(User.Identity.GetTenantId(), year, month, day, Request.GetTimeOffset()));
        }

        [Route("branches/{year}/{month}/{day}")]
        [HttpGet]
        public async Task<IActionResult> GetBranchesForDay(int year, int month, int day)
        {
            return Ok(await _deliveryRoutesService.GetBranchesForDay(User.Identity.GetTenantId(), year, month, day, Request.GetTimeOffset()));
        }

        [Route("{year}/{month}/{day}")]
        [HttpPost]
        public async Task<IActionResult> EditRoutesForDay(int year, int month, int day, [FromBody]EditDeliveryRouteRequest request)
        {
            return Ok(await _deliveryRoutesService.EditRoutesForDay(User.Identity.GetTenantId(), User.Identity.GetUserId(), year, month, day, request.Routes));
        }

        [Route("drivers")]
        [HttpPost]
        public async Task<IActionResult> CreateDriver(Driver driver)
        {
            return Ok(await _deliveryRoutesService.CreateDriver(User.Identity.GetTenantId(), User.Identity.GetUserId(), driver));
        }

        [Route("cars")]
        [HttpPost]
        public async Task<IActionResult> CreateCar(Vehicle vehicle)
        {
            return Ok(await _deliveryRoutesService.CreateVehicle(User.Identity.GetTenantId(), User.Identity.GetUserId(), vehicle));
        }

        [Route("warehouses")]
        [HttpPost]
        public async Task<IActionResult> CreateWarehouse(Warehouse warehouse)
        {
            return Ok(await _deliveryRoutesService.CreateWarehouse(User.Identity.GetTenantId(), User.Identity.GetUserId(), warehouse));
        }

        [Route("warehouses/{id}")]
        [HttpPut]
        public async Task<IActionResult> UpdateWarehouse(int id, Warehouse warehouse)
        {
            if (warehouse.Id != id)
                return BadRequest();

            await _deliveryRoutesService.UpdateWarehouse(User.Identity.GetTenantId(), User.Identity.GetUserId(), warehouse);
            return Ok();
        }

        [Route("warehouses/delete")]
        [HttpPut]
        public async Task<IActionResult> DeleteWarehouse([FromBody] int[] items)
        {
            await _deliveryRoutesService.DeleteWarehouses(User.Identity.GetTenantId(), User.Identity.GetUserId(), items);
            return Ok();
        }

        [Route("warehouses")]
        [HttpGet]
        public async Task<IActionResult> GetWarehouses()
        {
            return Ok(await _deliveryRoutesService.GetWarehouses(User.Identity.GetTenantId()));
        }

        [Route("cars/{id}")]
        [HttpPut]
        public async Task<IActionResult> UpdateCar(int id, Vehicle vehicle)
        {
            if (vehicle.Id != id)
                return BadRequest();

            await _deliveryRoutesService.UpdateVehicle(User.Identity.GetTenantId(), User.Identity.GetUserId(), vehicle);
            return Ok();
        }

        [Route("cars/delete")]
        [HttpPut]
        public async Task<IActionResult> Delete([FromBody]int[] items)
        {
            await _deliveryRoutesService.DeleteVehicles(User.Identity.GetTenantId(), User.Identity.GetUserId(), items);
            return Ok();
        }

        [Route("drivers")]
        [HttpGet]
        public async Task<IActionResult> GetDrivers()
        {
            return Ok(await _deliveryRoutesService.GetDrivers(User.Identity.GetTenantId()));
        }

        [Route("drivers/{id}")]
        [HttpPut]
        public async Task<IActionResult> UpdateDriver(int id, Driver driver)
        {
            if (driver.Id != id)
                return BadRequest();

            await _deliveryRoutesService.UpdateDriver(User.Identity.GetTenantId(), User.Identity.GetUserId(), driver);
            return Ok();
        }

        [Route("drivers/delete")]
        [HttpPut]
        public async Task<IActionResult> DeleteDriver([FromBody]int[] items)
        {
            await _deliveryRoutesService.DeleteDrivers(User.Identity.GetTenantId(), User.Identity.GetUserId(), items);
            return Ok();
        }

        [Route("cars")]
        [HttpGet]
        public async Task<IActionResult> GetVehicles()
        {
            return Ok(await _deliveryRoutesService.GetCars(User.Identity.GetTenantId()));
        }

        [Route("excel/{year}/{month}/{day}")]
        [HttpPost]
        public async Task<IActionResult> GetExcel(int year, int month, int day)
        {
            var memoryStream = await _deliveryRoutesService.ExportToExcel(User.Identity.GetTenantId(), year, month, day, Request.GetTimeOffset());
            return File(memoryStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        }

        [Route("plan/excel/{year}/{month}/{day}")]
        [HttpPost]
        public async Task<IActionResult> GetDailyPlanningExcel(int year, int month, int day, [FromBody]GetDailyPlanningRequest request)
        {
            return Ok(await _deliveryRoutesService.ExportDailyPlanningToExcel(User.Identity.GetTenantId(), request.Ids, year, month, day, Request.GetTimeOffset()));
        }

        [Route("vertical/excel/{year}/{month}/{day}")]
        [HttpPost]
        public async Task<IActionResult> GetVerticalPlanningExcel(int year, int month, int day, [FromBody] GetDailyPlanningRequest request)
        {
            return Ok(await _deliveryRoutesService.ExportVerticalPlanningToExcel(User.Identity.GetTenantId(), request.Ids, year, month, day, Request.GetTimeOffset()));
        }

        [Route("plan/{year}/{month}/{day}")]
        [HttpPost]
        public async Task<IActionResult> GetDailyPlanning(int year, int month, int day, [FromBody]GetDailyPlanningRequest request)
        {
            return Ok(await _deliveryRoutesService.GetDailyPlanning(User.Identity.GetTenantId(), request.Ids, year, month, day, Request.GetTimeOffset()));
        }

        public class GetDailyPlanningRequest
        {
            public int[] Ids { get; set; } 
        }

        public class EditDeliveryRouteRequest
        {
            public EditDeliveryRoute[] Routes;
        }

    }

}