package OO;
import java.sql.*;
import java.lang.*;

public class ClasseJdbc
{
  /**
   * Este atributo representa a conexão com o banco de dados.
   */
  protected Connection conexao = null;

  /**
   * Este atributo contém o nome do driver jdbc a ser utilizado
   */
  protected String driver_class;

  /**
   * Este atributo contém o string de conexão a ser utilizado para conectar ao
   * banco de dados.
   */
  protected String connect_string;

  /**
   * Este atributo contém o nome do usuário do banco de dados.
   */
  protected String usuario;

  /**
   * Este atributo representa a senha do usuário.
   */
  protected String senha;

  /***
      Método    : ClasseJdbc
      Parâmetro : nenhum
      Retorno   : nada
      Algoritmo : método construtor sem parâmetros.
  ***/
  public ClasseJdbc()
   {
     this.setConexao(null);
     this.setDriver("");
     this.setURLConexao("");
     this.setUsuario("");
     this.setSenha("");
   }

  /***
      Método    : ClasseJdbc
      Parâmetro : nenhum
      Retorno   : nada
      Algoritmo : método construtor com parâmetros.
  ***/
  public ClasseJdbc(String driver_class, String connect_string,
                    String usuario,      String senha )
   {
     this.setConexao(null);
     this.setDriver(driver_class);
     this.setURLConexao(connect_string);
     this.setUsuario(usuario);
     this.setSenha(senha);
   }

  /***
      Método    : getConexao
      Parâmetro : nenhum
      Retorno   : Connection
      Algoritmo : retorna o conteúdo do atributo conexao.
  ***/
  private Connection getConexao()
  {
    return this.conexao;
  }

  /***
      Método    : getDriver
      Parâmetro : nenhum
      Retorno   : String
      Algoritmo : retorna o conteúdo do atributo driver_class.
  ***/
  private String getDriver()
  {
    return this.driver_class;
  }

  /***
      Método    : getURLConexao
      Parâmetro : nenhum
      Retorno   : String
      Algoritmo : retorna o conteúdo do atributo connect_string.
  ***/
  private String getURLConexao()
  {
    return this.connect_string;
  }

  /***
      Método    : getUsuario
      Parâmetro : nenhum
      Retorno   : String
      Algoritmo : retorna o conteúdo do atributo usuario.
  ***/
  private String getUsuario()
  {
    return this.usuario;
  }

  /***
      Método    : getSenha
      Parâmetro : nenhum
      Retorno   : String
      Algoritmo : retorna o conteúdo do atributo senha.
  ***/
  private String getSenha()
  {
    return this.senha;
  }

  /***
      Método    : setConexao
      Parâmetro : Connection
      Retorno   : nada
      Algoritmo : altera o conteúdo do atributo conexao.
  ***/
  public void setConexao(Connection conexao)
  {
    this.conexao = conexao;
  }


  /***
      Método    : setDriver
      Parâmetro : String
      Retorno   : nada
      Algoritmo : altera o conteúdo do atributo driver_class.
  ***/
  private void setDriver(String nomeDriver)
  {
    this.driver_class = nomeDriver;
  }

  /***
      Método    : setURLConexao
      Parâmetro : String
      Retorno   : nada
      Algoritmo : altera o conteúdo do atributo connect_string.
  ***/
  private void setURLConexao(String url)
  {
    this.connect_string = url;
  }

  /***
      Método    : setUsuario
      Parâmetro : String
      Retorno   : nada
      Algoritmo : altera o conteúdo do atributo usuario.
  ***/
  private void setUsuario(String usuario)
  {
    this.usuario = usuario;
  }

  /***
      Método    : getSenha
      Parâmetro : String
      Retorno   : nada
      Algoritmo : altera o conteúdo do atributo senha.
  ***/
  private void setSenha(String senha)
  {
    this.senha = senha;
  }

  /***
      Método    : carregarDriver
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta carregar um driver jdbc.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean carregarDriver()
  {
    try
    {
      Class.forName(this.getDriver());
      System.out.println("carregou driver");
      return true;
    }
    catch (ClassNotFoundException e)
    {
      System.out.println("Erro ao carregar driver\n"+e.toString());
    }
    return false;
  }


  /***
      Método    : estabelecerConexao
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta estabelecer uma conexão com um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean estabelecerConexao(boolean autoCommit)
  {
    try
    {
      if (( this.getUsuario().length() == 0 )
      ||  ( this.getSenha().length()   == 0 ))
        {
          this.setConexao(DriverManager.getConnection(this.getURLConexao()));
        }
      else
        {
          this.setConexao(DriverManager.getConnection(this.getURLConexao(),
                                      this.getUsuario(), this.getSenha()));
        }
      this.setAutoCommit(autoCommit);
      return true;
    }
    catch (SQLException e)
    {
      System.out.println("Erro ao estabelecer conexao\n"+e.toString());
    }
   return false;
  }

  /***
      Método    : tabela
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta executar um comando sql relativo a criação,
                  exclusão ou alteração de uma tabela.
  ***/
  public boolean tabela(String sql)
  {
    try
    {
      Statement stmt = this.getConexao().createStatement();
      if ( stmt.executeUpdate(sql) > 0 )
        {
          return true;
        }
    }
    catch (SQLException e)
    {
      System.out.println("Erro ao exercutar um comando sql sobre uma tabela no banco de dados");
      System.out.println(e.toString());
    }
    return false;
  }

  /***
      Método    : inserir
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta inserir em uma tabela em um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean inserir(String sql)
  {
    try
    {
      Statement stmt = this.getConexao().createStatement();
      if ( stmt.executeUpdate(sql) > 0 )
        {
          return true;
        }
    }
    catch (SQLException e)
    {
      System.out.println("Erro ao inserir no banco de dados\n"+e.toString());
    }
    return false;
  }

  /***
      Método    : alterar
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta alterar em uma tabela em um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean alterar(String sql)
  {
    try
    {
      Statement stmt = this.getConexao().createStatement();
      //if ( stmt.executeUpdate(sql) > 0 )
      if ( stmt.executeUpdate(sql) >=0 )
        {
          return true;
        }
    }
    catch(SQLException e)
    {
      System.out.println( "Erro ao alterar no banco de dados\n"+e.toString());
    }
   return false;
  }

  /***
      Método    : excluir
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta excluir em uma tabela em um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean excluir(String sql)
  {
    try
    {
      Statement stmt = this.getConexao().createStatement();
      if ( stmt.executeUpdate(sql) > 0 )
        {
          return true;
        }
    }
    catch(SQLException e)
    {
      System.out.println( "Erro ao excluir no banco de dados\n"+e.toString());
    }
   return false;
  }

  /***
      Método    : consultar
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Tenta consultar em uma tabela em um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public ResultSet consultar(String sql)
  {
    try
    {
      Statement stmt = this.getConexao().createStatement();
      ResultSet rset = stmt.executeQuery(sql);
      return rset;
    }
    catch(SQLException e)
    {
      System.out.println( "Erro ao consultar no banco de dados\n"+e.toString());
    }
    return null;
  }

  /***
      Método    : fecharConexao
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Fecha uma conexão com um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean fecharConexao()
  {
    try
    {
      //fecha conexao
      this.getConexao().close();
    }
    catch( SQLException e )
    {
      // Erro ao encerrar uma conexão
      System.out.println( e.toString());
      return false;
    }

    // Conexão encerrada com sucesso.
    return true;
  }

  /***
      Método    : rollback
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Defaz as alterações em um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean rollback()
  {
    try
    {
      // executa o rollback
      this.getConexao().rollback();
    }
    catch (SQLException e)
    {
      // Erro ao executar um rollback
      System.out.println(e.toString());
      return false;
    }
    return true;
  }

  /***
      Método    : commit
      Parâmetro : nenhum
      Retorno   : boolean
      Algoritmo : Efetiva as alterações em um banco de dados.
                  Devolve verdadeiro se conseguir.
  ***/
  public boolean commit()
  {
    try
    {
      // executa o commit
      this.getConexao().commit();
    }
    catch (SQLException e)
    {
      // Erro ao executar um commit
      System.out.println(e.toString());
      return false;
    }
    return true;
  }

  /***
      Método    : setAutoCommit
      Parâmetro : boolean
      Retorno   : nada
      Algoritmo : Altera o autocommit.
  ***/
  public void setAutoCommit(boolean autoCommit)
  {
    try
    {
      this.getConexao().setAutoCommit(autoCommit);
    }
    catch (SQLException e)
    {
      System.out.println(e.toString());
      return;
    }
  }

}