using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using MSAdminUsuarios.Context;
using MSAdminUsuarios.Dto;
using MSAdminUsuarios.Models;
using Security;

namespace MSAdminUsuarios.Controllers
{
    [Route("[controller]")]
    [ApiController]
    public class UsuariosTempController : ControllerBase
    {
        private readonly ModelContext _context;
        private readonly ILogger<UsuariosTempController> _logger;
        private ErrorModel _errorModel;
        private readonly Encripter _encript = new();

        public UsuariosTempController(ModelContext context, ILogger<UsuariosTempController> logger)
        {
            _context = context;
            _logger = logger;
            _errorModel = new ErrorModel();
        }

        [HttpGet]
        public async Task<IActionResult> Get()
        {
            _errorModel = new ErrorModel();
            try
            {
                List<USUARIOSTEMP> externos = await _context.USUARIOSTEMP.OrderBy(q => q.NU_PK_USUTMP).ToListAsync();

                return Ok(externos);
            }
            catch (Exception)
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Error con la base de datos.");
                return BadRequest(_errorModel);
            }
        }

        [HttpPost]
        public async Task<IActionResult> Post(USUARIOSTEMP nuevo)
        {
            _errorModel = new ErrorModel();
            try
            {
                if (nuevo == null)
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("No se envió solicitud.");
                    return Conflict(_errorModel);
                }

                //USUARIOSTEMP? existe = await _context.USUARIOSTEMP.FirstOrDefaultAsync(ut => ut.NU_PK_USUTMP == nuevo.NU_PK_USUTMP);
                //if (existe == null) 

                if (nuevo.TX_UUID_USUMS == null)
                {
                    USUARIOSTEMP? existeEmailTemp = await _context.USUARIOSTEMP.FirstOrDefaultAsync(ut => ut.TX_CORREO_USUMS == nuevo.TX_CORREO_USUMS);
                    if (existeEmailTemp != null)
                    {
                        if (existeEmailTemp.NU_ESTADO_USUMS == 0)
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("Ya existe un usuario inactivo con ese correo electronico.");
                            return Conflict(_errorModel);
                        }
                        else
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("Ya existe un usuario activo con ese correo electronico.");
                            return Conflict(_errorModel);
                        }
                    }
                    
                    USUARIOSTEMP? existe = await _context.USUARIOSTEMP.FirstOrDefaultAsync(ut => ut.NU_TIPODOC_USUMS == nuevo.NU_TIPODOC_USUMS && ut.TX_PKDOC_USUMS == nuevo.TX_PKDOC_USUMS);
                    if (existe != null) {
                        if (existe.NU_ESTADO_USUMS == 0)
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("Ya existe un usuario inactivo con ese número de documento.");
                            return Conflict(_errorModel);
                        }
                        else
                        {
                            _errorModel.error = true;
                            _errorModel.cuerpo.Add("Ya existe un usuario activo con ese número de documento.");
                            return Conflict(_errorModel);
                        }
                    }
                    else
                    {
                        Guid uuid = Guid.NewGuid();
                        var UUID = uuid.ToString();
                        nuevo.TX_UUID_USUMS = UUID;

                        _context.USUARIOSTEMP.Add(nuevo);
                        await _context.SaveChangesAsync();

                        _errorModel.error = false;
                        _errorModel.cuerpo.Add("Solicitud de usuario temporal creada correctamente.");
                        return Ok(_errorModel);
                    }
                }
                else
                {
                    USUARIOSTEMP? existe = _context.USUARIOSTEMP.FirstOrDefault(ut => ut.TX_UUID_USUMS == nuevo.TX_UUID_USUMS);
                    if (existe == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin usuario no existe.");
                        return Conflict(_errorModel);
                    }

                    existe.NU_TIPODOC_USUMS = nuevo.NU_TIPODOC_USUMS;
                    existe.TX_PRIMERNOM_USUMS = nuevo.TX_PRIMERNOM_USUMS;
                    existe.TX_SEGUNDONOM_USUMS = nuevo.TX_SEGUNDONOM_USUMS;
                    existe.TX_PRIMERAPELL_USUMS = nuevo.TX_PRIMERAPELL_USUMS;
                    existe.TX_SEGUNDOAPELL_USUMS = nuevo.TX_SEGUNDOAPELL_USUMS;
                    //existe.TX_CELULAR_USUMS = nuevo.TX_CELULAR_USUMS;
                    existe.TX_TELEFONO_USUMS = nuevo.TX_TELEFONO_USUMS;
                    existe.TX_CORREO_USUMS = nuevo.TX_CORREO_USUMS;
                    //existe.TX_DIRECCION_USUMS = nuevo.TX_DIRECCION_USUMS;
                    //existe.BL_PERTENCEIPS_USUMS = nuevo.BL_PERTENCEIPS_USUMS;
                    existe.TX_NOMBRE_PVD = nuevo.TX_NOMBRE_PVD;
                    //existe.BL_VIENELDAP_USUMS = nuevo.BL_VIENELDAP_USUMS;
                    //existe.NU_GRUPO_USUMS = nuevo.NU_GRUPO_USUMS;
                    //existe.NU_CARGO_USUMS = nuevo.NU_CARGO_USUMS;
                    //existe.NU_MODALIDADCTT_USUMS = nuevo.NU_MODALIDADCTT_USUMS;
                    //existe.TX_SEDES_USUMS = nuevo.TX_SEDES_USUMS;
                    //existe.NU_BLOQUEO_USUMS = nuevo.NU_BLOQUEO_USUMS;
                    //existe.NU_TIPOUSUARIO_USUMS = nuevo.NU_TIPOUSUARIO_USUMS;
                    //existe.TX_REGPROF_MDC = nuevo.TX_REGPROF_MDC;
                    existe.NU_ESTADO_USUMS = 1;
                    existe.FE_INICIOACTIVACION_USUTMP = nuevo.FE_INICIOACTIVACION_USUTMP;
                    existe.FE_FINACTIVACION_USUTMP = nuevo.FE_FINACTIVACION_USUTMP;

                    _context.USUARIOSTEMP.Update(existe);
                    await _context.SaveChangesAsync();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Solicitud de usuario temporal actualizada correctamente.");
                    return Ok(_errorModel);
                }
            }
            catch (Exception)
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Error con la base de datos.");
                return BadRequest(_errorModel);
            }
        }

        [HttpPatch]
        public async Task<IActionResult> Patch(USUARIOSTEMP editado)
        {
            _errorModel = new ErrorModel();
            try
            {
                if (editado == null)
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("No se envió solicitud.");
                    return Conflict(_errorModel);
                }

                USUARIOSTEMP? existente = await _context.USUARIOSTEMP.FirstOrDefaultAsync(ut => ut.NU_PK_USUTMP == editado.NU_PK_USUTMP);
                if (existente == null)
                {
                    _errorModel.error = true;
                    _errorModel.cuerpo.Add("Diseño no encontrado.");
                    return Conflict(_errorModel);
                }

                _context.Entry(existente).CurrentValues.SetValues(editado);
                await _context.SaveChangesAsync();

                _errorModel.error = false;
                _errorModel.cuerpo.Add("Solicitud de usuario temporal guardado correctamente.");
                return Ok(_errorModel);
            }
            catch (Exception)
            {
                _errorModel.error = true;
                _errorModel.cuerpo.Add("Error con la base de datos.");
                return BadRequest(_errorModel);
            }
        }

        [HttpPost("UsuarioPerfilesTemp")]
        public async Task<IActionResult> PostUsuarioPerfilesTemp(UsuarioPerfilesDTO nuevo)
        {
            ErrorModel _errorModel = new ErrorModel();
            using (var transaccion = _context.Database.BeginTransaction())
            {
                try
                {
                    if (nuevo == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin datos a guardar.");
                        return Conflict(_errorModel);
                    }

                    transaccion.CreateSavepoint("InicioCreacionUsuarioPerfiles");

                    if (nuevo.usuario == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Sin usuario a guardar.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.usuario.TX_CORREO_USUMS == null && nuevo.usuario.TX_LOGINNAME_USUMS == null)
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Indique algún correo.");
                        return Conflict(_errorModel);
                    }

                    if (nuevo.usuario.TX_UUID_USUMS == null) 
                    {
                        _errorModel.error = true;
                        _errorModel.cuerpo.Add("Temporal sin codigo.");
                        return Conflict(_errorModel);
                    }
                    else
                    {
                        USUARIO? existeUUID = _context.USUARIOSMs.FirstOrDefault(usu => usu.TX_UUID_USUMS == nuevo.usuario.TX_UUID_USUMS);
                        if (existeUUID == null)
                        {
                            USUARIO? existeEmail = await _context.USUARIOSMs.FirstOrDefaultAsync(usu => usu.TX_CORREO_USUMS == nuevo.usuario.TX_CORREO_USUMS);
                            if (existeEmail != null)
                            {
                                if (existeEmail.NU_ESTADO_USUMS == 0)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario inactivo con ese correo electronico.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeEmail.NU_ESTADO_USUMS == 1)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario activo con ese correo electronico.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeEmail.NU_ESTADO_USUMS == 2)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario bloqueado con ese correo electronico.");
                                    return Conflict(_errorModel);
                                }
                            }

                            USUARIO? existeDoc = await _context.USUARIOSMs.FirstOrDefaultAsync(usu => usu.NU_TIPODOC_USUMS == nuevo.usuario.NU_TIPODOC_USUMS && usu.TX_PKDOC_USUMS == nuevo.usuario.TX_PKDOC_USUMS);
                            if (existeDoc != null)
                            {
                                if (existeDoc.NU_ESTADO_USUMS == 0)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario inactivo con ese número de documento.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeDoc.NU_ESTADO_USUMS == 1)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario activo con ese número de documento.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeDoc.NU_ESTADO_USUMS == 2)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario activo bloqueado con ese número de documento.");
                                    return Conflict(_errorModel);
                                }
                            }
                            //_errorModel.error = true;
                            //_errorModel.cuerpo.Add("Sin usuario no existe.");
                            //return Conflict(_errorModel);
                            USUARIOSTEMP? existeTemp = _context.USUARIOSTEMP.FirstOrDefault(ut => ut.TX_PKDOC_USUMS == nuevo.usuario.TX_PKDOC_USUMS);
                            if (existeTemp != null)
                            {
                                if (nuevo.usuario.TX_PASSWORD_USUMS == null)
                                {
                                    nuevo.usuario.TX_PASSWORD_USUMS = nuevo.usuario.TX_PKDOC_USUMS;
                                }

                                if (nuevo.usuario.TX_PASSWORD_USUMS != null)
                                {
                                    nuevo.usuario.TX_PASSWORD_USUMS = _encript.EncryptPwd(nuevo.usuario.TX_PASSWORD_USUMS);
                                }

                                if (nuevo.usuario.TX_SEDES_USUMS == null || nuevo.usuario.TX_SEDES_USUMS.Length == 0)
                                {
                                    nuevo.usuario.TX_SEDES_USUMS = "[0]";
                                }

                                nuevo.usuario.NU_INICIO_PRIMERAVEZ_USUMS = 0;
                                nuevo.usuario.BL_VIENELDAP_USUMS = 0;
                                nuevo.usuario.TX_UUID_USUMS = existeTemp.TX_UUID_USUMS;
                                nuevo.usuario.TX_LOGINNAME_USUMS = nuevo.usuario.TX_CORREO_USUMS;
                                //nuevo.usuario.TX_PASSWORD_USUMS = _encript.EncryptPwd(nuevo.usuario.TX_PKDOC_USUMS!);

                                //if (nuevo.usuario.TX_PASSWORD_USUMS == null || nuevo.usuario.TX_PASSWORD_USUMS == "")
                                //{
                                //    nuevo.usuario.TX_PASSWORD_USUMS = _encript.EncryptPwd(nuevo.usuario.TX_PKDOC_USUMS!);
                                //}

                                _context.USUARIOSMs.Add(nuevo.usuario);
                                await _context.SaveChangesAsync();
                                //_errorModel.cuerpo.Add("Usuario Temporal creado correctamente");
                            }
                        }
                        else
                        {
                            USUARIO? existeEmail = await _context.USUARIOSMs.FirstOrDefaultAsync(usu => usu.TX_CORREO_USUMS == nuevo.usuario.TX_CORREO_USUMS && usu.TX_UUID_USUMS != nuevo.usuario.TX_UUID_USUMS);
                            if (existeEmail != null)
                            {
                                if (existeEmail.NU_ESTADO_USUMS == 0)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario inactivo con ese correo electronico.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeEmail.NU_ESTADO_USUMS == 1)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario activo con ese correo electronico.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeEmail.NU_ESTADO_USUMS == 2)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario bloqueado con ese correo electronico.");
                                    return Conflict(_errorModel);
                                }
                            }

                            USUARIO? existeDoc = await _context.USUARIOSMs.FirstOrDefaultAsync(usu => usu.NU_TIPODOC_USUMS == nuevo.usuario.NU_TIPODOC_USUMS && usu.TX_PKDOC_USUMS == nuevo.usuario.TX_PKDOC_USUMS && usu.TX_UUID_USUMS != nuevo.usuario.TX_UUID_USUMS);
                            if (existeDoc != null)
                            {
                                if (existeDoc.NU_ESTADO_USUMS == 0)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario inactivo con ese número de documento.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeDoc.NU_ESTADO_USUMS == 1)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario activo con ese número de documento.");
                                    return Conflict(_errorModel);
                                }
                                else if (existeDoc.NU_ESTADO_USUMS == 2)
                                {
                                    _errorModel.error = true;
                                    _errorModel.cuerpo.Add("Ya existe un usuario activo con ese número de documento.");
                                    return Conflict(_errorModel);
                                }
                            }

                            existeUUID.NU_TIPODOC_USUMS = nuevo.usuario.NU_TIPODOC_USUMS;
                            existeUUID.TX_PRIMERNOM_USUMS = nuevo.usuario.TX_PRIMERNOM_USUMS;
                            existeUUID.TX_SEGUNDONOM_USUMS = nuevo.usuario.TX_SEGUNDONOM_USUMS;
                            existeUUID.TX_PRIMERAPELL_USUMS = nuevo.usuario.TX_PRIMERAPELL_USUMS;
                            existeUUID.TX_SEGUNDOAPELL_USUMS = nuevo.usuario.TX_SEGUNDOAPELL_USUMS;
                            //existeUUID.TX_CELULAR_USUMS = nuevo.usuario.TX_CELULAR_USUMS;
                            existeUUID.TX_TELEFONO_USUMS = nuevo.usuario.TX_TELEFONO_USUMS;
                            existeUUID.TX_CORREO_USUMS = nuevo.usuario.TX_CORREO_USUMS;
                            //existeUUID.TX_DIRECCION_USUMS = nuevo.usuario.TX_DIRECCION_USUMS;
                            //existeUUID.BL_PERTENCEIPS_USUMS = nuevo.usuario.BL_PERTENCEIPS_USUMS;
                            existeUUID.TX_NOMBRE_PVD = nuevo.usuario.TX_NOMBRE_PVD;
                            //existeUUID.BL_VIENELDAP_USUMS = nuevo.usuario.BL_VIENELDAP_USUMS;
                            //existeUUID.NU_GRUPO_USUMS = nuevo.usuario.NU_GRUPO_USUMS;
                            //existeUUID.NU_CARGO_USUMS = nuevo.usuario.NU_CARGO_USUMS;
                            //existeUUID.NU_MODALIDADCTT_USUMS = nuevo.usuario.NU_MODALIDADCTT_USUMS;
                            //existeUUID.TX_SEDES_USUMS = nuevo.usuario.TX_SEDES_USUMS;
                            //existeUUID.NU_BLOQUEO_USUMS = nuevo.usuario.NU_BLOQUEO_USUMS;
                            //existeUUID.NU_TIPOUSUARIO_USUMS = nuevo.usuario.NU_TIPOUSUARIO_USUMS;
                            //existeUUID.TX_REGPROF_MDC = nuevo.usuario.TX_REGPROF_MDC;
                            existeUUID.NU_ESTADO_USUMS = nuevo.usuario.NU_ESTADO_USUMS;
                            existeUUID.FE_INICIOACTIVACION_USUTMP = nuevo.usuario.FE_INICIOACTIVACION_USUTMP;
                            existeUUID.FE_FINACTIVACION_USUTMP = nuevo.usuario.FE_FINACTIVACION_USUTMP;

                            if (existeUUID.TX_PASSWORD_USUMS == null || existeUUID.TX_PASSWORD_USUMS == "")
                            {
                                existeUUID.TX_PASSWORD_USUMS = _encript.EncryptPwd(nuevo.usuario.TX_PKDOC_USUMS!);
                            }

                            _context.USUARIOSMs.Update(existeUUID);
                            await _context.SaveChangesAsync();
                            //_errorModel.cuerpo.Add("Usuario Temporal Actualizado correctamente");
                        }
                    }

                    USUARIO? creado = await _context.USUARIOSMs.FirstOrDefaultAsync(us => us.TX_UUID_USUMS == nuevo.usuario.TX_UUID_USUMS);

                    if (nuevo.perfiles != null && creado != null)
                    {
                        // Se cambia a estado 0 todos los perfiles por usuario existentes
                        var existe_plfxusu = _context.PERFILESPORUSUARIOs.Where(x => x.BL_ESTADO_PFLXUSU == 1 && x.TX_UUID_USUMS == creado.TX_UUID_USUMS).ToList();

                        foreach (var pu in existe_plfxusu)
                        {
                            pu.BL_ESTADO_PFLXUSU = 0;
                        }
                        _context.PERFILESPORUSUARIOs.UpdateRange(existe_plfxusu);
                        await _context.SaveChangesAsync();

                        foreach (PERFILPORUSUARIO pxu in nuevo.perfiles)
                        {
                            if (pxu != null)
                            {
                                PERFILPORUSUARIO? existe = _context.PERFILESPORUSUARIOs.FirstOrDefault(pu => pu.TX_UUID_PFL == pxu.TX_UUID_PFL && pu.TX_UUID_USUMS == pxu.TX_UUID_USUMS);
                                if (existe != null)
                                {
                                    existe.BL_ESTADO_PFLXUSU = 1;
                                    _context.Update(existe);
                                    await _context.SaveChangesAsync();
                                }
                                else
                                {
                                    pxu.BL_ESTADO_PFLXUSU = 1;
                                    pxu.TX_UUID_USUMS = nuevo.usuario.TX_UUID_USUMS;
                                    _context.PERFILESPORUSUARIOs.Add(pxu);
                                    await _context.SaveChangesAsync();

                                }
                            }
                        }

                        /*List<PERFILPORUSUARIO> perUsuEliminiado = _context.PERFILESPORUSUARIOs.Where(pu => pu.TX_UUID_USUMS == creado.TX_UUID_USUMS && pu.BL_ESTADO_PFLXUSU == 0).ToList();
                        _context.PERFILESPORUSUARIOs.RemoveRange(perUsuEliminiado);
                        await _context.SaveChangesAsync();*/

                    }

                    transaccion.Commit();

                    _errorModel.error = false;
                    _errorModel.cuerpo.Add("Proceso realizado correctamente");
                    return Ok(_errorModel);
                }
                catch (Exception e)
                {
                    transaccion.RollbackToSavepoint("InicioCreacionUsuarioPerfiles");
                    return BadRequest(e.Message);
                }
            }
        }
    }
}