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

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

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

        #region CRUD

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

                string sql = @"
                INSERT INTO Contas
                (
                    TIPO,
                    CLIENTE,
                    FORNECEDOR,
                    COD_CLIENTE,
                    COD_FORNECEDOR,
                    VENCIMENTO,
                    PAGO,
                    PLANO_CONTAS,
                    OBSERVACAO,
                    VALOR,
                    REFERENCIA,
                    FCOBRANCA,
                    PARCELA,
                    ECF_DINHEIRO,
                    ECF_CHEQUE,
                    ECF_CARTAO,
                    ECF_BOLETO,
                    ECF_TROCO,
                    DATA_DOCTO,
                    JUROS,
                    DESCONTO,
                    CFOP,
                    CLISTSERV,
                    PMVAST,
                    PREDBCST,
                    VBCICMSST,
                    AICMSST,
                    VICMSST,
                    DATA_PGTO,
                    COD_CORRENTE,
                    OBS_COB
                )
                VALUES
                (
                    @TIPO,
                    @CLIENTE,
                    @FORNECEDOR,
                    @COD_CLIENTE,
                    @COD_FORNECEDOR,
                    @VENCIMENTO,
                    @PAGO,
                    @PLANO_CONTAS,
                    @OBSERVACAO,
                    @VALOR,
                    @REFERENCIA,
                    @FCOBRANCA,
                    @PARCELA,
                    @ECF_DINHEIRO,
                    @ECF_CHEQUE,
                    @ECF_CARTAO,
                    @ECF_BOLETO,
                    @ECF_TROCO,
                    @DATA_DOCTO,
                    @JUROS,
                    @DESCONTO,
                    @CFOP,
                    @CLISTSERV,
                    @PMVAST,
                    @PREDBCST,
                    @VBCICMSST,
                    @AICMSST,
                    @VICMSST,
                    @DATA_PGTO,
                    @COD_CORRENTE,
                    @OBS_COB
                )";

                using SqlCommand cmd =
                    new(sql, conn);

                PreencherParametrosInserir(
                    cmd,
                    modelo);

                conn.Open();

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

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

                string sql = @"
                UPDATE Contas
                SET
                    CODIGO = @CODIGO,
                    TIPO = @TIPO,
                    CLIENTE = @CLIENTE,
                    FORNECEDOR = @FORNECEDOR,
                    COD_CLIENTE = @COD_CLIENTE,
                    COD_FORNECEDOR = @COD_FORNECEDOR,
                    VENCIMENTO = @VENCIMENTO,
                    PAGO = @PAGO,
                    PLANO_CONTAS = @PLANO_CONTAS,
                    OBSERVACAO = @OBSERVACAO,
                    VALOR = @VALOR,
                    REFERENCIA = @REFERENCIA,
                    FCOBRANCA = @FCOBRANCA,
                    PARCELA = @PARCELA,
                    ECF_DINHEIRO = @ECF_DINHEIRO,
                    ECF_CHEQUE = @ECF_CHEQUE,
                    ECF_CARTAO = @ECF_CARTAO,
                    ECF_BOLETO = @ECF_BOLETO,
                    ECF_TROCO = @ECF_TROCO,
                    DATA_DOCTO = @DATA_DOCTO,
                    JUROS = @JUROS,
                    DESCONTO = @DESCONTO,
                    CFOP = @CFOP,
                    CLISTSERV = @CLISTSERV,
                    PMVAST = @PMVAST,
                    PREDBCST = @PREDBCST,
                    VBCICMSST = @VBCICMSST,
                    AICMSST = @AICMSST,
                    VICMSST = @VICMSST,
                    DATA_PGTO = @DATA_PGTO,
                    COD_CORRENTE = @COD_CORRENTE,
                    OBS_COB = @OBS_COB
                WHERE ID_CONTAS =
                @ID_CONTAS";

                using SqlCommand cmd =
                    new(sql, conn);

                PreencherParametrosAlterar(
                    cmd,
                    modelo);

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

                conn.Open();

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

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

                string sql = @"
                DELETE FROM Contas
                WHERE ID_CONTAS =
                @ID_CONTAS";

                using SqlCommand cmd =
                    new(sql, conn);

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

                conn.Open();

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

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

            string sql = @"
            SELECT *
            FROM Contas
            WHERE ID_CONTAS =
            @ID_CONTAS";

            using SqlCommand cmd =
                new(sql, conn);

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

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

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

            return null;
        }//Carregar

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

            using SqlConnection conn =
                new(connectionString);

            string sql = @"
            SELECT *
            FROM Contas
            ORDER BY ID_CONTAS DESC";

            using SqlCommand cmd =
                new(sql, conn);

            conn.Open();

            using SqlDataReader dr =
                cmd.ExecuteReader();

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

            return lista;
        }//Listar
        public List<ModeloContas> Listar(string valor)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE CLIENTE LIKE @VALOR
            OR FORNECEDOR LIKE @VALOR
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@VALOR",
                $"%{valor}%");
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorValores
        public List<ModeloContas> ListarPorTipo(string tipo)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE TIPO = @TIPO
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, 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<ModeloContas> ListarPorCliente(string cliente)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE CLIENTE = @CLIENTE
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@CLIENTE",
                cliente);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorCliente
        public List<ModeloContas> ListarPorFornecedor(string fornecedor)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE FORNECEDOR = @FORNECEDOR
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@FORNECEDOR",
                fornecedor);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorFornecedor
        public List<ModeloContas> ListarPorPlanoContas(string planoContas)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE PLANO_CONTAS = @PLANO_CONTAS
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@PLANO_CONTAS",
                planoContas);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorPlanoContas
        public List<ModeloContas> ListarPorVencimento(string vencimento)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE VENCIMENTO = @VENCIMENTO
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@VENCIMENTO",
                vencimento);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorVencimento
        public List<ModeloContas> ListarPorPago(string pago)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE PAGO = @PAGO
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@PAGO",
                pago);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorPago
        public List<ModeloContas> ListarPorReferencia(string referencia)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE REFERENCIA = @REFERENCIA
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@REFERENCIA",
                referencia);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorReferencia
        public List<ModeloContas> ListarPorFCOBRANCA(string fCobranca)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE FCOBRANCA = @FCOBRANCA
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@FCOBRANCA",
                fCobranca);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorFCOBRANCA
        public List<ModeloContas> ListarPorParcela(string parcela)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE PARCELA = @PARCELA
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@PARCELA",
                parcela);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorParcela
        public List<ModeloContas> ListarPorPlanoContasECliente(string planoContas, string cliente)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE PLANO_CONTAS = @PLANO_CONTAS
            AND CLIENTE = @CLIENTE
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@PLANO_CONTAS",
                planoContas);
            cmd.Parameters.AddWithValue(
                "@CLIENTE",
                cliente);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorPlanoContasECliente
        public List<ModeloContas> ListarPorPlanoContasEFornecedor(string planoContas, string fornecedor)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE PLANO_CONTAS = @PLANO_CONTAS
            AND FORNECEDOR = @FORNECEDOR
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@PLANO_CONTAS",
                planoContas);
            cmd.Parameters.AddWithValue(
                "@FORNECEDOR",
                fornecedor);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorPlanoContasEFornecedor
        public List<ModeloContas> ListarPorPlanoContasEReferencia(string planoContas, string referencia)
        {
            List<ModeloContas> lista = [];
            using SqlConnection conn =
                new(connectionString);
            string sql = @"
            SELECT *
            FROM Contas
            WHERE PLANO_CONTAS = @PLANO_CONTAS
            AND REFERENCIA = @REFERENCIA
            ORDER BY ID_CONTAS DESC";
            using SqlCommand cmd =
                new(sql, conn);
            cmd.Parameters.AddWithValue(
                "@PLANO_CONTAS",
                planoContas);
            cmd.Parameters.AddWithValue(
                "@REFERENCIA",
                referencia);
            conn.Open();
            using SqlDataReader dr =
                cmd.ExecuteReader();
            while (dr.Read())
            {
                lista.Add(
                    PreencherModelo(dr));
            }
            return lista;
        }//ListarPorPlanoContasEReferencia

        #endregion

        #region HELPERS

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static void PreencherParametrosInserir(
            SqlCommand cmd,
            ModeloContas modelo)
        {
            cmd.Parameters.AddWithValue("@TIPO", modelo.TIPO);
            cmd.Parameters.AddWithValue("@CLIENTE", modelo.CLIENTE);
            cmd.Parameters.AddWithValue("@FORNECEDOR", modelo.FORNECEDOR);
            cmd.Parameters.AddWithValue("@COD_CLIENTE", modelo.COD_CLIENTE);
            cmd.Parameters.AddWithValue("@COD_FORNECEDOR", modelo.COD_FORNECEDOR);
            cmd.Parameters.AddWithValue("@VENCIMENTO", modelo.VENCIMENTO);
            cmd.Parameters.AddWithValue("@PAGO", modelo.PAGO);
            cmd.Parameters.AddWithValue("@PLANO_CONTAS", modelo.PLANO_CONTAS);
            cmd.Parameters.AddWithValue("@OBSERVACAO", modelo.OBSERVACAO);
            cmd.Parameters.AddWithValue("@VALOR", modelo.VALOR);
            cmd.Parameters.AddWithValue("@REFERENCIA", modelo.REFERENCIA);
            cmd.Parameters.AddWithValue("@FCOBRANCA", modelo.FCOBRANCA);
            cmd.Parameters.AddWithValue("@PARCELA", modelo.PARCELA);

            cmd.Parameters.AddWithValue("@ECF_DINHEIRO", modelo.ECF_DINHEIRO);
            cmd.Parameters.AddWithValue("@ECF_CHEQUE", modelo.ECF_CHEQUE);
            cmd.Parameters.AddWithValue("@ECF_CARTAO", modelo.ECF_CARTAO);
            cmd.Parameters.AddWithValue("@ECF_BOLETO", modelo.ECF_BOLETO);
            cmd.Parameters.AddWithValue("@ECF_TROCO", modelo.ECF_TROCO);

            cmd.Parameters.AddWithValue("@DATA_DOCTO", modelo.DATA_DOCTO);
            cmd.Parameters.AddWithValue("@JUROS", modelo.JUROS);
            cmd.Parameters.AddWithValue("@DESCONTO", modelo.DESCONTO);

            cmd.Parameters.AddWithValue("@CFOP", modelo.CFOP);
            cmd.Parameters.AddWithValue("@CLISTSERV", modelo.CLISTSERV);

            cmd.Parameters.AddWithValue("@PMVAST", modelo.PMVAST);
            cmd.Parameters.AddWithValue("@PREDBCST", modelo.PREDBCST);
            cmd.Parameters.AddWithValue("@VBCICMSST", modelo.VBCICMSST);
            cmd.Parameters.AddWithValue("@AICMSST", modelo.AICMSST);
            cmd.Parameters.AddWithValue("@VICMSST", modelo.VICMSST);

            cmd.Parameters.AddWithValue("@DATA_PGTO", modelo.DATA_PGTO);
            cmd.Parameters.AddWithValue("@COD_CORRENTE", modelo.COD_CORRENTE);
            cmd.Parameters.AddWithValue("@OBS_COB", modelo.OBS_COB);
        }

        private static void PreencherParametrosAlterar(
            SqlCommand cmd,
            ModeloContas modelo)
        {
            cmd.Parameters.AddWithValue(
                "@CODIGO",
                modelo.CODIGO);

            PreencherParametrosInserir(
                cmd,
                modelo);
        }

        #endregion
    }
}