using Microsoft.Data.SqlClient;
using MLL;
using System;
using System.Collections.Generic;
using System.Data;

namespace DALL
{
    public class DALLContratos
    {
        private readonly string connectionString;

        public DALLContratos(string conexao)
        {
            connectionString = conexao;
        }

        #region CRUD

        public bool Inserir(ModeloContrato modelo)
        {
            try
            {
                using SqlConnection conn =
                    new(connectionString);

                string sql = @"
                INSERT INTO Contratos
                (
                    EmpresaId,
                    ClienteId,
                    Descricao,
                    Observacoes,
                    Valor,
                    DataInicio,
                    DataValidade,
                    FranquiaTempo,
                    Ativo,
                    CriadoEm,
                    AtualizadoEm
                )
                VALUES
                (
                    @EmpresaId,
                    @ClienteId,
                    @Descricao,
                    @Observacoes,
                    @Valor,
                    @DataInicio,
                    @DataValidade,
                    @FranquiaTempo,
                    @Ativo,
                    @CriadoEm,
                    @AtualizadoEm
                )";

                using SqlCommand cmd =
                    new(sql, conn);

                PreencherParametros(
                    cmd,
                    modelo);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
            catch
            {
                return false;
            }
        }

        public bool Alterar(ModeloContrato modelo)
        {
            try
            {
                using SqlConnection conn =
                    new(connectionString);

                string sql = @"
                UPDATE Contratos
                SET
                    EmpresaId = @EmpresaId,
                    ClienteId = @ClienteId,
                    Descricao = @Descricao,
                    Observacoes = @Observacoes,
                    Valor = @Valor,
                    DataInicio = @DataInicio,
                    DataValidade = @DataValidade,
                    FranquiaTempo = @FranquiaTempo,
                    Ativo = @Ativo,
                    AtualizadoEm = @AtualizadoEm
                WHERE Id = @Id";

                using SqlCommand cmd =
                    new(sql, conn);

                PreencherParametros(
                    cmd,
                    modelo);

                cmd.Parameters.AddWithValue(
                    "@Id",
                    modelo.Id);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
            catch
            {
                return false;
            }
        }

        public bool Excluir(int id)
        {
            try
            {
                using SqlConnection conn =
                    new(connectionString);

                string sql = @"
                DELETE FROM Contratos
                WHERE Id = @Id";

                using SqlCommand cmd =
                    new(sql, conn);

                cmd.Parameters.AddWithValue(
                    "@Id",
                    id);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
            catch
            {
                return false;
            }
        }

        public ModeloContrato? Carregar(int id)
        {
            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM Contratos
            WHERE Id = @Id";

            using SqlCommand cmd =
                new(sql, conn);

            cmd.Parameters.AddWithValue(
                "@Id",
                id);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            if (dr.Read())
            {
                return PreencherModelo(dr);
            }

            return null;
        }

        public List<ModeloContrato> Listar()
        {
            List<ModeloContrato> lista = [];

            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM Contratos
            ORDER BY Id DESC";

            using SqlCommand cmd =
                new(sql, conn);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }

            return lista;
        }

        #endregion

        #region VIEWS

        public List<ModeloContrato> ListarAtivos()
        {
            return ExecutarLista(@"
            SELECT *
            FROM Contratos
            WHERE Ativo = 1");
        }

        public List<ModeloContrato> ListarInativos()
        {
            return ExecutarLista(@"
            SELECT *
            FROM Contratos
            WHERE Ativo = 0");
        }

        public List<ModeloContrato> ListarVencidos()
        {
            return ExecutarLista(@"
            SELECT *
            FROM Contratos
            WHERE
                DataValidade < GETDATE()
                AND Ativo = 1");
        }

        public List<ModeloContrato> ListarVigentes()
        {
            return ExecutarLista(@"
            SELECT *
            FROM Contratos
            WHERE
                DataValidade >= GETDATE()
                AND Ativo = 1");
        }

        public List<ModeloContrato> ListarPorCliente(
            int clienteId)
        {
            List<ModeloContrato> lista = [];

            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM Contratos
            WHERE ClienteId = @ClienteId";

            using SqlCommand cmd =
                new(sql, conn);

            cmd.Parameters.AddWithValue(
                "@ClienteId",
                clienteId);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }

            return lista;
        }
        public List<ModeloContrato> ListarPorEmpresa(
            int empresaId)
        {
            List<ModeloContrato> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contratos
            WHERE EmpresaId = @EmpresaId";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@EmpresaId",
                empresaId);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }
        public List<ModeloContrato> ListarPorValor(
            decimal valorMinimo,
            decimal valorMaximo)
        {
            List<ModeloContrato> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contratos
            WHERE Valor BETWEEN @ValorMinimo AND @ValorMaximo";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@ValorMinimo",
                valorMinimo);
            cmd.Parameters.AddWithValue(
                "@ValorMaximo",
                valorMaximo);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }
        public List<ModeloContrato> ListarPorDataValidade(
            DateTime dataInicio,
            DateTime dataFim)
        {
            List<ModeloContrato> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contratos
            WHERE DataValidade BETWEEN @DataInicio AND @DataFim";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@DataInicio",
                dataInicio);
            cmd.Parameters.AddWithValue(
                "@DataFim",
                dataFim);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }
        public List<ModeloContrato> ListarContratosEncerrados(
            int dias)
        {
            List<ModeloContrato> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contratos
            WHERE
                DataValidade < GETDATE()
                AND DATEDIFF(DAY, DataValidade, GETDATE()) <= @Dias";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@Dias",
                dias);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }

        #endregion

        #region DASHBOARD

        public DataTable Dashboard()
        {
            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT
                COUNT(*) AS TOTAL,
                SUM(
                    CASE
                        WHEN Ativo = 1
                        THEN 1
                        ELSE 0
                    END
                ) AS ATIVOS,
                SUM(
                    CASE
                        WHEN Ativo = 0
                        THEN 1
                        ELSE 0
                    END
                ) AS INATIVOS,
                SUM(Valor) AS VALOR_TOTAL
            FROM Contratos";

            using SqlCommand cmd =
                new(sql, conn);

            using SqlDataAdapter da =
                new(cmd);

            DataTable dt = new();

            da.Fill(dt);

            return dt;
        }

        #endregion

        #region HELPERS

        private List<ModeloContrato> ExecutarLista(
            string sql)
        {
            List<ModeloContrato> lista = [];

            using SqlConnection conn =
                new(connectionString);

            using SqlCommand cmd =
                new(sql, conn);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }

            return lista;
        }

        private static ModeloContrato PreencherModelo(
            SqlDataReader dr)
        {
            return new ModeloContrato
            {
                Id =
                    Convert.ToInt32(
                        dr["Id"]),

                EmpresaId =
                    Convert.ToInt32(
                        dr["EmpresaId"]),

                ClienteId =
                    Convert.ToInt32(
                        dr["ClienteId"]),

                Descricao =
                    dr["Descricao"] == DBNull.Value
                    ? null
                    : Convert.ToString(
                        dr["Descricao"]),

                Observacoes =
                    dr["Observacoes"] == DBNull.Value
                    ? null
                    : Convert.ToString(
                        dr["Observacoes"]),

                Valor =
                    Convert.ToDecimal(
                        dr["Valor"]),

                DataInicio =
                    dr["DataInicio"] == DBNull.Value
                    ? (DateTime?)null
                    : Convert.ToDateTime(
                        dr["DataInicio"]),

                DataValidade =
                    dr["DataValidade"] == DBNull.Value
                    ? (DateTime?)null
                    : Convert.ToDateTime(
                        dr["DataValidade"]),

                FranquiaTempo =
                    dr["FranquiaTempo"] == DBNull.Value
                    ? (int?)null
                    : Convert.ToInt32(
                        dr["FranquiaTempo"]),

                Ativo =
                    Convert.ToBoolean(
                        dr["Ativo"]),

                CriadoEm =
                    dr["CriadoEm"] == DBNull.Value
                    ? (DateTime?)null
                    : Convert.ToDateTime(
                        dr["CriadoEm"]),

                AtualizadoEm =
                    dr["AtualizadoEm"] == DBNull.Value
                    ? (DateTime?)null
                    : Convert.ToDateTime(
                        dr["AtualizadoEm"])
            };
        }

        private static void PreencherParametros(
            SqlCommand cmd,
            ModeloContrato modelo)
        {
            cmd.Parameters.AddWithValue(
                "@EmpresaId",
                modelo.EmpresaId);

            cmd.Parameters.AddWithValue(
                "@ClienteId",
                modelo.ClienteId);

            cmd.Parameters.AddWithValue(
                "@Descricao",
                string.IsNullOrWhiteSpace(
                    modelo.Descricao)
                ? DBNull.Value
                : modelo.Descricao);

            cmd.Parameters.AddWithValue(
                "@Observacoes",
                string.IsNullOrWhiteSpace(
                    modelo.Observacoes)
                ? DBNull.Value
                : modelo.Observacoes);

            cmd.Parameters.AddWithValue(
                "@Valor",
                modelo.Valor);

            cmd.Parameters.AddWithValue(
                "@DataInicio",
                modelo.DataInicio.HasValue
                ? modelo.DataInicio.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@DataValidade",
                modelo.DataValidade.HasValue
                ? modelo.DataValidade.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@FranquiaTempo",
                modelo.FranquiaTempo.HasValue
                ? modelo.FranquiaTempo.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@Ativo",
                modelo.Ativo);

            cmd.Parameters.AddWithValue(
                "@CriadoEm",
                modelo.CriadoEm.HasValue
                ? modelo.CriadoEm.Value
                : DBNull.Value);

            cmd.Parameters.AddWithValue(
                "@AtualizadoEm",
                modelo.AtualizadoEm.HasValue
                ? modelo.AtualizadoEm.Value
                : DBNull.Value);
        }

        #endregion
    }
}