ackage com.example.test2;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.text.format.DateFormat;
import android.util.Log;

public class DatabaseHelper extends SQLiteOpenHelper {

  /**
   * Este é o endereço onde o android salva os bancos de dados criado pela aplicação,
   * /data/data/<namespace da aplicacao>/databases/
   */
  private static String DBPATH = "/data/data/com.example.test2/databases/";

  // Este é o nome do banco de dados
  private static String DBNAME ="scaDB.db";
 
  private static String TAG ="DatabaseHelper:";
 
  //private SQLiteDatabase db;
  private SQLiteDatabase myDataBase;
 
  private Context context;
 
  /**
   * O construtor necessita do contexto da aplicação
   */
  public DatabaseHelper(Context context) {
    /* O primeiro argumento é o contexto da aplicacao
     * O segundo argumento é o nome do banco de dados
     * O terceiro é um pondeiro para manipulação de dados
     * O quarto é a versão do banco de dados
     */
    super(context, "scaDB.db", null, 1);
    Log.i(TAG, "DatabaseHelper Construtor");
    this.context = context;
  }
 
  /**
   * Os métodos onCreate e onUpgrade precisam ser sobreescrito
   */
  @Override
  public void onCreate(SQLiteDatabase db) {
    /*
     * Estamos utilizando o banco do assets, por isso o
     * código antigo deste método não é mais necessário.
     */
      Log.i(TAG, "onCreate");
  }
 
  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    /*
     * Estamos criando a primeira versão do nosso banco de dados,
     * então não precisamos fazer nenhuma alteração neste método.
     *
     */
      Log.i(TAG, "onUpgrade");
  }
 
  /**
   * Método auxiliar que verifica a existencia do banco
   * da aplicação.
   */
  private boolean checkDataBase() {
   
    SQLiteDatabase db = null;    
    try {
      String path = DBPATH + DBNAME;
      db =
        SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READONLY);
      db.close();
      Log.i(TAG, "checkDataBase");
    } catch (SQLiteException e) {
      // O banco não existe
        Log.d(TAG, "banco dados não existe");
    }    
    // Retorna verdadeiro se o banco existir, pois o ponteiro irá existir,
    // se não houver referencia é porque o banco não existe
    return db != null;
  }
 
  private void createDataBase()
  throws Exception {    
    // Primeiro temos que verificar se o banco da aplicação
    // já foi criado
    boolean exists = checkDataBase();    
    if(!exists) {
      // Chamaremos esse método para que o android
      // crie um banco vazio e o diretório onde iremos copiar
      // no banco que está no assets.
      this.getReadableDatabase();
      Log.i(TAG, "createDataBase ");
      // Se o banco de dados não existir iremos copiar o nosso
      // arquivo em /assets para o local onde o android os salva
      try {
        copyDatabase();
      } catch (IOException e) {
          Log.d(TAG, "Erro ao copiar arquivo");
        throw new Error("Não foi possível copiar o arquivo");
      }      
    }
  }
 
  /**
   * Esse método é responsável por copiar o banco do diretório
   * assets para o diretório padrão do android.
   */
    private void copyDatabase() throws IOException {

        String dbPath = DBPATH + DBNAME;

        // Abre o arquivo o destino para copiar o banco de dados
        OutputStream dbStream = new FileOutputStream(dbPath);
        Log.i(TAG, "copyDatabase ");
        // Abre Stream do nosso arquivo que esta no assets
        InputStream dbInputStream = context.getAssets().open("scaDB.db");

        byte[] buffer = new byte[1024];
        int length;
        while ((length = dbInputStream.read(buffer)) > 0) {
            dbStream.write(buffer, 0, length);
        }

        dbInputStream.close();
        dbStream.flush();
        dbStream.close();

    }
 
  public SQLiteDatabase getDatabase() {
   
    try{
      // Verificando se o banco já foi criado e se não foi o
      // mesmo é criado.
      createDataBase();
     
      // Abrindo database
      String path = DBPATH + DBNAME;
      Log.i(TAG, "getDatabase");
      return SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.OPEN_READWRITE);
    }catch (Exception e) { Log.d(TAG, "retornar banco de dados");
      // Se não conseguir copiar o banco um novo será retornado
      return getWritableDatabase();
     
    }

  }
  /*
  public void openDataBase() throws SQLException{
     
    //Open the database
    String myPath = DBPATH + DBNAME;
    myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
     
    }
     
    @Override
    public synchronized void close() {
     
    if(myDataBase != null)
    myDataBase.close();
     
    super.close();
     
    }*/
 
  public Cursor getCartao(String id, boolean needAll) {    
        String[] args = null;
        String query = "Select * from TAB_UTENTES";
        Log.i(TAG, "getCartao");
        if(!needAll){
            query += " WHERE CARTAO = ?";
            args = new String[]{id};
        }
        return (getReadableDatabase().rawQuery(query, args));  
    }
 
  public Cursor getActividades(String id, boolean needAll) {    
        String[] args = null;
        String query = "SELECT * FROM TAB_ACTIVIDADE";
        Log.i(TAG, "getActividades");
        if(!needAll){
            query += " WHERE UTENTE_ID = (SELECT ID FROM TAB_UTENTES WHERE CARTAO = ?)";
            args = new String[]{id};
        }
        return (getReadableDatabase().rawQuery(query, args));  
    }
 
    public Cursor verfMovimento(String Cartao) {
        String[] args = null;
        String query = "SELECT  MAX(ROWID),CARTAO,TABTIPMOV_ID from MOVIMENTOS";
        Log.i(TAG, "verfMovimento");

        query += " WHERE CARTAO = ?";
        args = new String[] { Cartao };

        return (getReadableDatabase().rawQuery(query, args));
    }
 
 
  public void InserirMovimentos(String _CARTAO,String _LEITOR_ID, int _TABTIPMOV_ID, String currentDateTimeString) {    
       try
       {
      String[] args = null;
        String query = "INSERT INTO MOVIMENTOS (CARTAO,LEITOR_ID,TABTIPMOV_ID,DATAMOV) " +
                "VALUES ('"+_CARTAO+"'," +
                            "'"+_LEITOR_ID+"'," +
                                "'"+_TABTIPMOV_ID+"'," +
                                        "'"+currentDateTimeString+"')";
        Log.i(TAG, "Função - InserirRegistos");                  
        getWritableDatabase().execSQL(query);  
       }
       catch( SQLException ex)
       {
           Log.i(TAG, "Exception: " + ex.getMessage());            
       }
       finally
       {
           getWritableDatabase().close();
       }
    }
 

}