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

namespace DAL
{
    public class DALLBackup
    {
        private readonly string _connectionString;
        public DALLBackup(string connectionString)
        {
            _connectionString = connectionString;
        }//metodo constructor para receber a string de conexão com o banco de dados

        public bool Inserir(ModeloBackup modelo)
        {
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = @"
        INSERT INTO Config_backup
        (
            nome,
            tipo_backup,
            origem,
            destino_tipo,
            destino_id,
            caminho_destino,
            compactar,
            usar_criptografia,
            algoritmo_criptografia,
            frequencia,
            horario,
            manter_ultimos,
            status_ultimo_backup,
            data_ultimo_backup,
            log_ultimo_backup,
            ativo,
            criado_em,
            atualizado_em
        )
        VALUES
        (
            @nome,
            @tipo_backup,
            @origem,
            @destino_tipo,
            @destino_id,
            @caminho_destino,
            @compactar,
            @usar_criptografia,
            @algoritmo_criptografia,
            @frequencia,
            @horario,
            @manter_ultimos,
            @status_ultimo_backup,
            @data_ultimo_backup,
            @log_ultimo_backup,
            @ativo,
            @criado_em,
            @atualizado_em
        )";

                SqlCommand cmd = new SqlCommand(query, conn);

                PreencherParametros(cmd, modelo);

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
        }//incluir
        public bool Atualizar(ModeloBackup modelo)
        {
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = @"
                UPDATE Config_backup
                SET
                    nome = @nome,
                    tipo_backup = @tipo_backup,
                    origem = @origem,
                    destino_tipo = @destino_tipo,
                    destino_id = @destino_id,
                    caminho_destino = @caminho_destino,
                    compactar = @compactar,
                    usar_criptografia = @usar_criptografia,
                    algoritmo_criptografia = @algoritmo_criptografia,
                    frequencia = @frequencia,
                    horario = @horario,
                    manter_ultimos = @manter_ultimos,
                    status_ultimo_backup = @status_ultimo_backup,
                    data_ultimo_backup = @data_ultimo_backup,
                    log_ultimo_backup = @log_ultimo_backup,
                    ativo = @ativo,
                    atualizado_em = @atualizado_em
                WHERE id = @id";

                SqlCommand cmd = new SqlCommand(query, conn);

                PreencherParametros(cmd, modelo);

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

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
        }//alterar
        public bool Excluir(int id)
        {
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "DELETE FROM Config_backup WHERE id = @id";

                SqlCommand cmd = new SqlCommand(query, conn);

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

                conn.Open();

                return cmd.ExecuteNonQuery() > 0;
            }
        }//excluir
        public ModeloBackup ObterPorId(int id)
        {
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "SELECT * FROM Config_backup WHERE id = @id";

                SqlCommand cmd = new SqlCommand(query, conn);

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

                conn.Open();

                SqlDataReader dr = cmd.ExecuteReader();

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

                return null;
            }
        }//CaregarModelo
        public List<ModeloBackup> Listar()
        {
            List<ModeloBackup> lista = new List<ModeloBackup>();

            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "SELECT * FROM Config_backup ORDER BY id DESC";

                SqlCommand cmd = new SqlCommand(query, conn);

                conn.Open();

                SqlDataReader dr = cmd.ExecuteReader();

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

            return lista;
        }//Listar
        public List<ModeloBackup> ListarAtivos()
        {
            List<ModeloBackup> lista = new List<ModeloBackup>();
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "SELECT * FROM Config_backup WHERE ativo = 1 ORDER BY id DESC";
                SqlCommand cmd = new SqlCommand(query, conn);
                conn.Open();
                SqlDataReader dr = cmd.ExecuteReader();
                while (dr.Read())
                {
                    lista.Add(PreencherModelo(dr));
                }
            }
            return lista;
        }//ListarAtivos
        public bool Desativar(int id)
        {
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "UPDATE Config_backup SET ativo = 0, atualizado_em = @atualizado_em WHERE id = @id";
                SqlCommand cmd = new SqlCommand(query, conn);
                cmd.Parameters.AddWithValue("@id", id);
                cmd.Parameters.AddWithValue("@atualizado_em", DateTime.Now);
                conn.Open();
                return cmd.ExecuteNonQuery() > 0;
            }
        }//Desativar
        public bool Ativar(int id)
        {
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "UPDATE Config_backup SET ativo = 1, atualizado_em = @atualizado_em WHERE id = @id";
                SqlCommand cmd = new SqlCommand(query, conn);
                cmd.Parameters.AddWithValue("@id", id);
                cmd.Parameters.AddWithValue("@atualizado_em", DateTime.Now);
                conn.Open();
                return cmd.ExecuteNonQuery() > 0;
            }
        }//Ativar
        public DataTable LocalizarTodos()
        {
            DataTable dt = new DataTable();
            using (SqlConnection conn = new SqlConnection(_connectionString))
            {
                string query = "SELECT * FROM Config_backup ORDER BY id DESC";
                SqlCommand cmd = new SqlCommand(query, conn);
                conn.Open();
                SqlDataAdapter da = new SqlDataAdapter(cmd);
                da.Fill(dt);
            }
            return dt;
        }//LocalizarTodos
        private static ModeloBackup PreencherModelo(SqlDataReader dr)
        {
            return new ModeloBackup
            {
                Id = Convert.ToInt32(dr["id"]),

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

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

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

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

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

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

                Compactar = Convert.ToBoolean(dr["compactar"]),

                UsarCriptografia = Convert.ToBoolean(dr["usar_criptografia"]),

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

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

                Horario = dr["horario"] == DBNull.Value
                    ? null
                    : (TimeSpan)dr["horario"],

                ManterUltimos = Convert.ToInt32(dr["manter_ultimos"]),

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

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

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

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

                CriadoEm = Convert.ToDateTime(dr["criado_em"]),

                AtualizadoEm = dr["atualizado_em"] == DBNull.Value
                    ? null
                    : Convert.ToDateTime(dr["atualizado_em"])
            };
        }
        private void PreencherParametros(SqlCommand cmd, ModeloBackup modelo)
        {
            cmd.Parameters.AddWithValue("@nome", modelo.Nome);
            cmd.Parameters.AddWithValue("@tipo_backup", modelo.TipoBackup);
            cmd.Parameters.AddWithValue("@origem", modelo.Origem);
            cmd.Parameters.AddWithValue("@destino_tipo", modelo.DestinoTipo);

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

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

            cmd.Parameters.AddWithValue("@compactar", modelo.Compactar);
            cmd.Parameters.AddWithValue("@usar_criptografia", modelo.UsarCriptografia);

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

            cmd.Parameters.AddWithValue("@frequencia", modelo.Frequencia);

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

            cmd.Parameters.AddWithValue("@manter_ultimos", modelo.ManterUltimos);

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

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

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

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

            cmd.Parameters.AddWithValue("@criado_em", modelo.CriadoEm);

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


}