using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using WebApplication3.Models;
using WebApplication3.Clases;

namespace WebApplication3.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class RecargasController : ControllerBase
    {
        private readonly AquiferContext _context;
        private TsRecargaController tsRecargaController;
        //private AcuiferoController aquiferController;

        public RecargasController(AquiferContext context)
        {
            _context = context;
            tsRecargaController = new TsRecargaController(context);
            //aquiferController = new AcuiferoController(context);
        }

        // GET: api/Recargas
        [HttpGet]
        public async Task<ActionResult<IEnumerable<DatosPozoRecarga>>> GetRecargas()
        {
            var recargas =  await _context.Recargas.ToListAsync();
            List<DatosPozoRecarga> result = new();

            foreach(Recarga r in recargas)
            {
                DatosPozoRecarga datosRecarga = new();
                datosRecarga.Id = r.Id;
                datosRecarga.Nombre = r.Nombre;
                datosRecarga.Latitud = r.Latitud;
                datosRecarga.Longitud = r.Longitud;
                datosRecarga.Simulacion = r.IdSimulacion;
                datosRecarga.Ts = tsRecargaController.GetTsRecarga(r.Id);
                result.Add(datosRecarga);
            }

            return result;
        }

        // GET: api/Recargas/5
        [HttpGet("{id}")]
        [ProducesResponseType(200)]
        [ProducesResponseType(404)]
        public async Task<ActionResult<DatosPozoRecarga>> GetRecarga(uint id)
        {
            var recarga = await _context.Recargas.FindAsync(id);

            if (recarga == null)
            {
                return NotFound();
            }

            DatosPozoRecarga datosRecarga = new DatosPozoRecarga();
            datosRecarga.Id = recarga.Id;
            datosRecarga.Nombre = recarga.Nombre;
            datosRecarga.Latitud = recarga.Latitud;
            datosRecarga.Longitud = recarga.Longitud;
            datosRecarga.Simulacion = recarga.IdSimulacion;
            datosRecarga.Ts = tsRecargaController.GetTsRecarga(id);


            return datosRecarga;

        }

        // PUT: api/Recargas/5
        [HttpPut("{id}")]
        [ProducesResponseType(201)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public async Task<IActionResult> PutRecarga(uint id, [FromBody] DatosPozoRecarga datos)
        {
            Recarga recarga = _context.Recargas.Find(id);

            if (id != recarga.Id)
            {
                return BadRequest();
            }

            
            recarga.IdSimulacion = (datos.Simulacion != null && recarga.IdSimulacion != datos.Simulacion) ? datos.Simulacion : recarga.IdSimulacion;
            recarga.Latitud = (datos.Latitud != null && recarga.Latitud != datos.Latitud) ? datos.Latitud : recarga.Latitud;
            recarga.Longitud = (datos.Longitud != null && recarga.Longitud != datos.Longitud) ? datos.Longitud : recarga.Longitud;
            recarga.Nombre = (datos.Nombre != null && recarga.Nombre != datos.Nombre) ? datos.Nombre : recarga.Nombre;
            

            //Para editar los datos de la TimeSerie haria falta un identificador más

            _context.Entry(recarga).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!RecargaExists((uint)id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetRecarga", new { id = recarga.Id }, recarga);
        }

        // POST: api/Recargas
        [HttpPost]
        [ProducesResponseType(201)]
        [ProducesResponseType(409)]
        public async Task<ActionResult<Recarga>> PostRecarga([FromBody] DatosPozoRecarga datos)
        {
            Recarga recarga = new Recarga();
            recarga.IdSimulacion = datos.Simulacion;
            recarga.Nombre = datos.Nombre;
            recarga.Latitud = datos.Latitud;
            recarga.Longitud = datos.Longitud;
            recarga.IdAcuifero = datos.Acuifero;

            _context.Recargas.Add(recarga);
            try
            {
                await _context.SaveChangesAsync();

                foreach(TimeSerie ts in datos.Ts)
                {
                    TsRecarga tsRecarga = new TsRecarga();
                    tsRecarga.IdRecarga = recarga.Id;
                    tsRecarga.MarcaTiempo = ts.Hora;
                    tsRecarga.Valor = ts.Valor;

                    await tsRecargaController.PostTsRecarga(tsRecarga);
                }
            }
            catch (DbUpdateException)
            {
                if (RecargaExists(recarga.Id))
                { 
                    return Conflict();
                }
                else
                {
                    throw;
                }
            }

            return CreatedAtAction("GetRecarga", new { id = recarga.Id }, recarga);
        }

        // DELETE: api/Recargas/5
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteRecarga(uint id)
        {
            var recarga = await _context.Recargas.FindAsync(id);
            if (recarga == null)
            {
                return NotFound();
            }

            _context.Recargas.Remove(recarga);
            await _context.SaveChangesAsync();

            return NoContent();
        }

        private bool RecargaExists(uint id)
        {
            return _context.Recargas.Any(e => e.Id == id);
        }

        [NonAction]
        public async void SetRecargasSimulacion(uint? acuiferoId, uint? simulacionId)
        {
            Recarga[] recargas = _context.Recargas.Where(x => x.IdAcuifero == acuiferoId && x.IdSimulacion == null).ToArray<Recarga>();

            foreach (Recarga r in recargas)
            {
                Recarga recarga = r.Copy(simulacionId);
                _context.Recargas.Add(recarga);

            }
            await _context.SaveChangesAsync();
        }

        [NonAction]
        public List<Recarga> GetRecargasSimulacion(uint? simulacionId)
        {
            List<Recarga> recargas = _context.Recargas.Where(x => x.IdSimulacion == simulacionId).ToList<Recarga>();

            return recargas;
        }

        [NonAction]
        public Recarga[] GetRecargasAcuifero(uint acuiferoId)
        {
            return _context.Recargas.Where(x => x.IdAcuifero == acuiferoId).ToArray<Recarga>();
        }

        [NonAction]
        public Recarga[] GetRecargasAcuiferoSimulacionInicial(uint acuiferoId)
        {
            return _context.Recargas.Where(x => x.IdAcuifero == acuiferoId && x.IdSimulacion == null).ToArray<Recarga>();
        }

        [NonAction]
        public List<TsRecarga> GetTsRecargaFromRecaga(uint? recarga)
        {
            List<TsRecarga> tsRecarga = _context.TsRecargas.Where(x => x.IdRecarga == recarga).ToList<TsRecarga>();

            return tsRecarga;
        }

        [NonAction]
        public async Task<ActionResult<IEnumerable<Recarga>>> ParseoFichero(uint aquifer, string file, uint simId)
        {
            Parser parser = new Parser();
            //string file = @"C:\Users\Admin\Desktop\ASD\infoPozos.VMW";
            RechargeData[] recharges = parser.ParseRechargeData(file, out string recharge_geometry);
            await SetRechargeGeometry(aquifer, recharge_geometry);

            string fileName = Utilities.String2Png(recharge_geometry);

            Byte[] bytes = System.IO.File.ReadAllBytes(fileName);
            String base64Image = Convert.ToBase64String(bytes);

            await SetRechargeMapColor(aquifer, base64Image);

            return await PostMultipleRecharges(aquifer,recharges,simId);
        }

        [NonAction]
        public async Task<Acuifero> SetRechargeGeometry(uint id, string recharge_geometry)
        {
            Acuifero aquifer = _context.Acuiferos.Find(id);

            aquifer.RechargeGeometry = recharge_geometry;

            _context.Entry(aquifer).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AcuiferoExists(id))
                {
                    return null;
                }
                else
                {
                    throw;
                }
            }

            return aquifer;
        }

        [NonAction]
        public async Task<bool> SetRechargeMapColor(uint id, string base64)
        {
            Acuifero aquifer = _context.Acuiferos.Find(id);

            aquifer.RechargeColorMap = base64;

            _context.Entry(aquifer).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AcuiferoExists(id))
                {
                    return false;
                }
                else
                {
                    throw;
                }
            }
            return true;
        }

        private bool AcuiferoExists(uint id)
        {
            return _context.Acuiferos.Any(e => e.Id == id);
        }

        [NonAction]
        public async Task<ActionResult<IEnumerable<Recarga>>> PostMultipleRecharges(uint aquifer, RechargeData[] recharges, uint simId)
        {
            foreach (RechargeData r in recharges)
            {
                Recarga recarga = r.ToRecarga(aquifer,simId);
                _context.Recargas.Add(recarga);

                try
                {
                    await _context.SaveChangesAsync();

                    foreach (TimeSerieInterno ts in r.Rates)
                    {

                        TsRecarga tsRecarga = new(); 
                        tsRecarga.IdRecarga = recarga.Id;
                        tsRecarga.MarcaTiempo = ts.Hora;
                        tsRecarga.MarcaTiempoEnd = ts.HoraEnd;
                        tsRecarga.Valor = ts.Valor;

                        await tsRecargaController.PostTsRecarga(tsRecarga);
                    }

                }
                catch (DbUpdateException)
                {
                    if (RecargaExists(recarga.Id))
                    {
                        return Conflict();
                    }
                    else
                    {
                        throw;
                    }
                }
            }

            return await _context.Recargas.ToListAsync();
        }
    }
}