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

namespace DAL
{
    public class DALLChamado
    {
        private readonly string connectionString;

        public DALLChamado(string connectionString)
        {
            this.connectionString = connectionString;
        }

        #region CRUD

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

            string query = @"
            INSERT INTO Chamado
            (
                TIPO,
                COD_CLIENTE,
                NOME_AVULSO,
                FONES,
                EMAIL,
                PARA,
                PRIORIDADE,
                REALIZADO,
                DIA_CHAMADO,
                OBS,
                ENDER_CLI
            )
            VALUES
            (
                @TIPO,
                @COD_CLIENTE,
                @NOME_AVULSO,
                @FONES,
                @EMAIL,
                @PARA,
                @PRIORIDADE,
                @REALIZADO,
                @DIA_CHAMADO,
                @OBS,
                @ENDER_CLI
            )";

            using SqlCommand cmd = new(query, conn);

            PreencherParametrosInserir(cmd, modelo);

            conn.Open();

            return cmd.ExecuteNonQuery() > 0;
        }//Inserir

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

            string query = @"
            UPDATE Chamado
            SET
                CODIGO = @CODIGO,
                TIPO = @TIPO,
                COD_CLIENTE = @COD_CLIENTE,
                NOME_AVULSO = @NOME_AVULSO,
                FONES = @FONES,
                EMAIL = @EMAIL,
                PARA = @PARA,
                PRIORIDADE = @PRIORIDADE,
                REALIZADO = @REALIZADO,
                DIA_CHAMADO = @DIA_CHAMADO,
                OBS = @OBS,
                ENDER_CLI = @ENDER_CLI
            WHERE ID_CHAMADO = @ID_CHAMADO";

            using SqlCommand cmd = new(query, conn);

            PreencherParametrosAlterar(cmd, modelo);

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

            conn.Open();

            return cmd.ExecuteNonQuery() > 0;
        }//Alterar

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

            string query = @"
            DELETE FROM Chamado
            WHERE ID_CHAMADO = @ID_CHAMADO";

            using SqlCommand cmd = new(query, conn);

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

            conn.Open();

            return cmd.ExecuteNonQuery() > 0;
        }//Excluir

        public ModeloChamado? ObterPorId(int id)
        {
            using SqlConnection conn = new(connectionString);

            string query = @"
            SELECT *
            FROM Chamado
            WHERE ID_CHAMADO = @ID_CHAMADO";

            using SqlCommand cmd = new(query, conn);

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

            conn.Open();

            using SqlDataReader dr = cmd.ExecuteReader();

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

            return null;
        }//ObterPorID
        public ModeloChamado CarregarModeloChamado(int id)
        {
            using SqlConnection conn = new(connectionString);

            string query = @"
            SELECT *
            FROM Chamado
            WHERE ID_CHAMADO = @ID_CHAMADO";

            using SqlCommand cmd = new(query, conn);

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

            conn.Open();

            using SqlDataReader dr = cmd.ExecuteReader();

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

#pragma warning disable CS8603 // Possível retorno de referência nula.
            return null;
#pragma warning restore CS8603 // Possível retorno de referência nula.
        }//CarregarModeloChamado

        #region LISTAGENS
        public List<ModeloChamado> Listar()
        {
            List<ModeloChamado> lista = [];

            using SqlConnection conn = new(connectionString);

            string query = @"
            SELECT *
            FROM Chamado
            ORDER BY ID_CHAMADO DESC";

            using SqlCommand cmd = new(query, conn);

            conn.Open();

            using SqlDataReader dr = cmd.ExecuteReader();

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

            return lista;
        }//listar
        public List<ModeloChamado> ListarPorCliente(string codCliente)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE COD_CLIENTE = @COD_CLIENTE
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@COD_CLIENTE", codCliente);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorCliente
        public List<ModeloChamado> ListarPorTipo(string tipo)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE TIPO = @TIPO
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@TIPO", tipo);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorTipo
        public List<ModeloChamado> ListarPorPrioridade(string prioridade)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE PRIORIDADE = @PRIORIDADE
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@PRIORIDADE", prioridade);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorPrioridade
        public List<ModeloChamado> ListarPorRealizado(string realizado)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE REALIZADO = @REALIZADO
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@REALIZADO", realizado);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorRealizado
        public List<ModeloChamado> ListarPorData(string diaChamado)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE DIA_CHAMADO = @DIA_CHAMADO
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@DIA_CHAMADO", diaChamado);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorData
        public List<ModeloChamado> ListarPorClienteETipo(string codCliente, string tipo)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE COD_CLIENTE = @COD_CLIENTE AND TIPO = @TIPO
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@COD_CLIENTE", codCliente);
            cmd.Parameters.AddWithValue("@TIPO", tipo);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorClienteETipo
        public List<ModeloChamado> ListarPorClienteERealizado(string codCliente, string realizado)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE COD_CLIENTE = @COD_CLIENTE AND REALIZADO = @REALIZADO
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@COD_CLIENTE", codCliente);
            cmd.Parameters.AddWithValue("@REALIZADO", realizado);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorClienteERealizado
        public List<ModeloChamado> ListarPorTipoERealizado(string tipo, string realizado)
        {
            List<ModeloChamado> lista = [];
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT *
            FROM Chamado
            WHERE TIPO = @TIPO AND REALIZADO = @REALIZADO
            ORDER BY ID_CHAMADO DESC";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@TIPO", tipo);
            cmd.Parameters.AddWithValue("@REALIZADO", realizado);
            conn.Open();
            using SqlDataReader dr = cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(PreencherModelo(dr));
            }
            return lista;
        }//ListarPorTipoERealizado
        public bool MarcarComoRealizado(int id)
        {
            using SqlConnection conn = new(connectionString);
            string query = @"
            UPDATE Chamado
            SET REALIZADO = 'S'
            WHERE ID_CHAMADO = @ID_CHAMADO";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@ID_CHAMADO", id);
            conn.Open();
            int rowsAffected = cmd.ExecuteNonQuery();
            return rowsAffected > 0;
        }//MarcarComoRealizado
        public bool MarcarComoPendente(int id)
        {
            using SqlConnection conn = new(connectionString);
            string query = @"
            UPDATE Chamado
            SET REALIZADO = 'N'
            WHERE ID_CHAMADO = @ID_CHAMADO";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@ID_CHAMADO", id);
            conn.Open();
            int rowsAffected = cmd.ExecuteNonQuery();
            return rowsAffected > 0;
        }//MarcarComoPendente
        public bool VerificarExistencia(int id)
        {
            using SqlConnection conn = new(connectionString);
            string query = @"
            SELECT COUNT(1)
            FROM Chamado
            WHERE ID_CHAMADO = @ID_CHAMADO";
            using SqlCommand cmd = new(query, conn);
            cmd.Parameters.AddWithValue("@ID_CHAMADO", id);
            conn.Open();
            int count = Convert.ToInt32(cmd.ExecuteScalar());
            return count > 0;
        }//VerificarExistencia

        #endregion

        #region HELPERS

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

                CODIGO = Convert.ToString(dr["CODIGO"]) ?? string.Empty,

                TIPO = Convert.ToString(dr["TIPO"]) ?? string.Empty,

                COD_CLIENTE = Convert.ToString(dr["COD_CLIENTE"]) ?? string.Empty,

                NOME_AVULSO = Convert.ToString(dr["NOME_AVULSO"]) ?? string.Empty,

                FONES = Convert.ToString(dr["FONES"]) ?? string.Empty,

                EMAIL = Convert.ToString(dr["EMAIL"]) ?? string.Empty,

                PARA = Convert.ToString(dr["PARA"]) ?? string.Empty,

                PRIORIDADE = Convert.ToString(dr["PRIORIDADE"]) ?? string.Empty,

                REALIZADO = Convert.ToString(dr["REALIZADO"]) ?? string.Empty,

                DIA_CHAMADO = Convert.ToString(dr["DIA_CHAMADO"]) ?? string.Empty,

                OBS = Convert.ToString(dr["OBS"]) ?? string.Empty,

                ENDER_CLI = Convert.ToString(dr["ENDER_CLI"]) ?? string.Empty
            };
        }

        private static void PreencherParametrosInserir(SqlCommand cmd, ModeloChamado modelo)
        {
            cmd.Parameters.AddWithValue("@TIPO",
                string.IsNullOrWhiteSpace(modelo.TIPO)
                ? DBNull.Value
                : modelo.TIPO);

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

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

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

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

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

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

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

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

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

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

        private static void PreencherParametrosAlterar(SqlCommand cmd, ModeloChamado modelo)
        {
            cmd.Parameters.AddWithValue("@CODIGO",
                string.IsNullOrWhiteSpace(modelo.CODIGO)
                ? DBNull.Value
                : modelo.CODIGO);

            PreencherParametrosInserir(cmd, modelo);
        }

        #endregion

        #region VIEWS

        public List<ModeloChamado> ListarTodos()
        {
            return ExecutarViewLista("SELECT * FROM VW_Chamados");
        }//ListarTodos

        public List<ModeloChamado> ListarPendentes()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosPendentes");
        }//ListarPendentes

        public List<ModeloChamado> ListarFinalizados()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosFinalizados");
        }//ListarFinalizados

        public List<ModeloChamado> ListarPrioridadeAlta()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosPrioridadeAlta");
        }//ListarPrioridadeAlta

        public List<ModeloChamado> ListarPrioridadeMedia()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosPrioridadeMedia");
        }//ListarPrioridadeMedia

        public List<ModeloChamado> ListarPrioridadeBaixa()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosPrioridadeBaixa");
        }//ListarPrioridadeBaixa

        public List<ModeloChamado> ListarAvulsos()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosAvulsos");
        }//ListarAvulsos

        public List<ModeloChamado> ListarClientes()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosClientes");
        }//ListarClientes

        public List<ModeloChamado> ListarHoje()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosHoje");
        }//ListarHoje

        public List<ModeloChamado> ListarVisita()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosVisita");
        }//ListarVisita

        public List<ModeloChamado> ListarRemotos()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosRemotos");
        }//ListarRemotos

        public List<ModeloChamado> ListarComEmail()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosComEmail");
        }//ListarComEmail

        public List<ModeloChamado> ListarSemEmail()
        {
            return ExecutarViewLista("SELECT * FROM VW_ChamadosSemEmail");
        }//ListarSemEmail

        #endregion

        #region DASHBOARD

        public DataTable ObterDashboard()
        {
            return ExecutarViewDataTable("SELECT * FROM VW_ChamadosDashboard");
        }//ObterDashboard

        #endregion

        #region HELPERS VIEWS

        private List<ModeloChamado> ExecutarViewLista(string query)
        {
            List<ModeloChamado> lista = [];

            using SqlConnection conn = new(connectionString);

            using SqlCommand cmd = new(query, conn);

            conn.Open();

            using SqlDataReader dr = cmd.ExecuteReader();

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

            return lista;
        }//ExecutarViewLista

        private DataTable ExecutarViewDataTable(string query)
        {
            DataTable dt = new();

            using SqlConnection conn = new(connectionString);

            using SqlDataAdapter da = new(query, conn);

            da.Fill(dt);

            return dt;
        }//ExecutarViewDataTable

        #endregion

        #endregion
    }
}