using System.Security.Cryptography;
using System.Text;
using Entidades.Dto;
using Entidades;
using Microsoft.EntityFrameworkCore;
using Entidades.Admin;
using System.Net;
using Modelo.Facade;

namespace Modelo;

public class RepositorioUsuarios : RepositorioBase<RepositorioUsuarios>
{

    public bool AltaUsuario(long Dni, Cliente clii, string Contraseña, List<int> grupos)
    {
        var con = Context;

        foreach (int i in grupos)
        {
            var g = con.Grupos.FirstOrDefault(x => x.Id == i);
            clii.Idgrupos.Add(g);
        }

        clii.Contraseña = Encoding.UTF8.GetBytes(HacerHash(Contraseña));

        con.Clientes.Add(clii);
        base.GenerarLog(con, Dni, "Creacion de usuario");
        return Guardar(con);
    }

    public (bool, long) Check2fa(string Email, string Pin)
    {
        var con = Context;
        var cli = con.Clientes.FirstOrDefault(x => x.Email == Email);
        if (cli == null || cli.F2a == null) return (false, 0);

        if (cli.F2a != Pin) return (false, 0);

        return (true, cli.Dni);
    }

    public bool SetF2aPin(string pin, string Email)
    {
        if (pin.Length != 6) return false;
        var con = Context;
        var cli = con.Clientes.FirstOrDefault(x => x.Email == Email);
        if (cli == null) return false;

        cli.F2a = pin;
        //no Necesita logs esto
        return Guardar(con);
    }
    public bool CheckEmailRecuperacion(string Email, string EmailRecuperacion)
    {
        var con = Context;
        Cliente cli = con.Clientes.FirstOrDefault(x => x.Email == Email);
        if (cli == null) return false;
        if (cli.EmailRecuperacion == EmailRecuperacion)
        {
            base.GenerarLog(con, cli.Dni, "Intento de recuperar Usuario");
            return true;
        }
        return false;
    }

    public bool SetEmailRecuperacion(string emailrecuperacion, Cliente cli)
    {
        var con = Context;
        Cliente clii = con.Clientes.FirstOrDefault(x => x.Dni == cli.Dni);
        if (clii == null) return false;
        clii.EmailRecuperacion = emailrecuperacion;
        base.GenerarLog(con, cli.Dni, "Set email Recuperacion");
        return Guardar(con);
    }

    public bool CambiarContraseña(string pass, Cliente cli)
    {
        var con = Context;
        var clii = con.Clientes.FirstOrDefault(x => x.Dni == cli.Dni);
        if (clii == null) return false;
        clii.Contraseña = Encoding.UTF8.GetBytes(HacerHash(pass));

        this.GenerarLog(con, cli.Dni, "Modificada contraseña");
        return Guardar(con);
    }

    public bool AltaInquilino(Cliente cli, long dni)
    {
        var con = Context;

        Grupo? grupo;
        //check por si la cuenta ya existe (puede ser propietario)
        Cliente? cli2 = con.Clientes.FirstOrDefault(x => x.Email == cli.Email);
        if (cli2 != null)
        {
            grupo = con.Grupos.Find(2);
            if (grupo == null || grupo.Id == 0) return false;
            cli2.Idgrupos.Add(grupo);
            return Guardar(con);
        }

        grupo = con.Grupos.Find(2);
        if (grupo == null || grupo.Id == 0) return false;

        con.Clientes.Add(cli);

        if (cli.Dni == 0) return false;

        cli.Idgrupos.Add(grupo);
        GenerarLog(con, dni, $"Alta Inquilino: {cli.Dni}");
        return Guardar(con);
    }

    public bool AltaPropietario(Cliente cli, long dni)
    {
        var con = Context;

        Grupo? grupo;
        //check por si la cuenta ya existe (puede ser propietario)
        Cliente? cli2 = con.Clientes.Find(cli.Dni);
        if (cli2 != null)
        {
            grupo = con.Grupos.Find(1);
            if (grupo == null || grupo.Id == 0) return false;
            cli2.Idgrupos.Add(grupo);
            return Guardar(con);
        }

        grupo = con.Grupos.Find(1);
        if (grupo == null || grupo.Id == 0) return false;

        con.Clientes.Add(cli);

        if (cli.Dni == 0) return false;

        cli.Idgrupos.Add(grupo);
        GenerarLog(con, dni, $"Alta Propietario: {cli.Dni}");
        return Guardar(con);
    }

    public bool ActualizarPropietario(Cliente cli)
    {
        var con = Context;
        Cliente? cliOld = con.Clientes.Find(cli.Dni);
        if (cliOld == null) return false;
        if (cli.Dni != cliOld.Dni) return false;

        cliOld = cli;
        return Guardar(con);
    }


    public bool CheckUsuario(LoginDto logindto)
    {
        if (logindto.Contraseña == null) return false;

        Cliente? usu = Context.Clientes.FirstOrDefault(a => a.Email == logindto.Email && a.Habilitado == 1ul);
        if (usu == null) return false;

        string Contraseña = HacerHash(logindto.Contraseña);


        string hashdb = Encoding.UTF8.GetString(usu.Contraseña);

        if (hashdb == Contraseña) return true;
        return false;

    }
    private string HacerHash(string pass)
    {
        var buf = SHA256.HashData(Encoding.UTF8.GetBytes(pass));
        return BitConverter.ToString(buf).Replace("-", "");
    }

    public bool CheckToken(string email, string token)
    {
        var usu = Context.Clientes.FirstOrDefault(x => x.Email == email);
        if (usu == null) return false;

        return usu.Token == token;
    }

    public void GuardarToken(LoginDto login, string tokenString, System.Net.IPAddress? remoteIpAddress, string? logout = null)
    {
        var con = Context;
        var usu = con.Clientes.FirstOrDefault(x => x.Email == login.Email);
        if (usu == null) return;
        usu.Token = tokenString;
        GenerarLog(con, usu.Dni, logout!=null? logout : "Login", remoteIpAddress);
        Guardar(con);
    }

    private void GenerarLog(AlquilaFacilContext con, long dni, string v, IPAddress? remoteIpAddress)
    {
        var Auditoria = new AuditoriaFacade(con);
        Auditoria.GenerarLogLogin(dni, v, remoteIpAddress);

    }

    public bool CheckGrupo(string email, string grupo)
    {
        var con = Context;
        var usu = con.Clientes.Include(x => x.Idgrupos).FirstOrDefault(x => x.Email == email);
        bool ret = false;

        if (usu != null && usu.Idgrupos != null)
        {
            Parallel.ForEach(usu.Idgrupos, (idGrupo, state) =>
            {
                if (idGrupo.Nombre == grupo)
                {
                    ret = true;
                    state.Break();
                }
            });
        }

        return ret;
    }

    public IEnumerable<Entidades.Admin.UsuarioAdmin> GetClientes()
    {
        var con = Context;
        var list = con.Clientes.ToList().Select(x => new Entidades.Admin.UsuarioAdmin
        {
            Dni = x.Dni,
            Email = x.Email,
            Nombre = x.Nombre + " " + x.Apellido,
            Habilitado = x.Habilitado
        });
        return list;
    }

    public bool AñadirClienteAGrupo(string email, string grupo, long dni)
    {
        var con = Context;

        var cli = con.Clientes.Include(x => x.Idgrupos).FirstOrDefault(x => x.Email == email);
        var gru = con.Grupos.FirstOrDefault(x => x.Nombre == grupo);

        if (cli == null || gru == null)
        {
            return false;
        }

        cli.Idgrupos.Add(gru);
        GenerarLog(con, dni, $"Añadir grupo: {gru.Nombre}");
        return Guardar(con);
    }

    public bool EliminarClienteAGrupo(string email, string grupo, long dniresponsable)
    {
        var con = Context;

        var cli = con.Clientes.Include(x => x.Idgrupos).FirstOrDefault(x => x.Email == email);
        var gru = con.Grupos.FirstOrDefault(x => x.Nombre == grupo);

        if (cli == null || gru == null)
        {
            return false;
        }
        cli.Idgrupos.Remove(gru);
        GenerarLog(con, dniresponsable, $"Eliminar de grupo: {gru.Nombre}");
        return Guardar(con);
    }

    public bool BajaCliente(long dni)
    {
        var con = Context;

        Cliente? cli = con.Clientes.Include(x => x.Idgrupos).FirstOrDefault(x => x.Dni == dni);
        if (cli == null) return false;

        if (cli.Habilitado == 0)
        {
            cli.Habilitado = 1;
        }
        else
        {
            cli.Habilitado = 0;
        }
        GenerarLog(con, cli.Dni, $"Baja cliente id: {cli.Dni}");
        return Guardar(con);
    }

    public Cliente? ObtenerClientePorDni(long dni)
    {
        var con = Context;
        Cliente? cli = con.Clientes.FirstOrDefault(x => x.Dni == dni);
        return cli;
    }

    public Cliente? ObtenerClientePorToken(string token)
    {
        var con = Context;
        Cliente? cli = con.Clientes.Include(x => x.NotificacioneDniclienteNavigations).FirstOrDefault(x => x.Token == token);

        if (cli == null || cli.Dni == 0) return null;
        return cli;
    }

    public bool PatchUsuario(UpdateUsuarioAdmin dto, long dni, long responsabledni)
    {
        var con = Context;
        var usu = con.Clientes.FirstOrDefault(x => x.Dni == dni);
        if (usu == null) return false;

        usu.Nombre = dto.Nombre;
        usu.Apellido = dto.Apellido;
        usu.Celular = dto.Celular;
        usu.Domicilio = dto.Domicilio;

        GenerarLog(con, responsabledni, "Patch Usuario");
        return Guardar(con);
    }
}