package br.com.datahelp;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.provider.BaseColumns;

public class DataHelper extends SQLiteOpenHelper {
   
    public Cursor c;
   
    //+-------------------------------------------------------+
    //| Configurações da base de dados - Alterar somente aqui |
    //| ------------------------INICIO----------------------- |
    //+-------------------------------------------------------+ 
    // Versão da base de dados
    private static final int DATABASE_VERSION = 1;    
    // Nome da base de dados
    private static final String DATABASE_NAME = "nome_da_minha_bd";    
    // Campo primary key
    private static final String PK = BaseColumns._ID;
    // Nomes das tabelas
    private static final String[] TABLE_NAMES = {"tabela1","tabela2","tabela3"};    
    // Campos das tabelas
    private static String[][][] TABLE_FIELDS = {{
        {PK,"INTEGER PRIMARY KEY"}, //campos da tabela 1
        {"campo1","TEXT"},
        {"campo2","INTEGER"},
        {"campo3","INTEGER"},
        {"campo4","INTEGER"},
    },{
        {PK,"INTEGER PRIMARY KEY"},
        {"campo1","TEXT"}, //campos da tabela 2
        {"campo2","INTEGER"},
        {"campo3","INTEGER"},
        {"campo4","INTEGER"},
    },{
        {PK,"INTEGER PRIMARY KEY"},
        {"campo1","TEXT"}, //campos da tabela 3
        {"campo2","INTEGER"},
        {"campo3","INTEGER"},
        {"campo4","INTEGER"},
    }};
    // Indices das tabelas
    private static String[][] TABLE_INDEX = {
        {PK,"campo1,campo3,"+PK}, //indices para a tabela "tabela1"
        {PK,"campo3,campo4,"+PK}, //indices para a tabela "tabela2"
        {PK,"campo1,campo2,"+PK} //indices para a tabela "tabela3"
    };
    //+-------------------------------------------------------+
    //| Configurações da base de dados - Alterar somente aqui |
    //| -------------------------FIM------------------------- |
    //+-------------------------------------------------------+
   
    public DataHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
 
    // Criando tabelas e indices
    @Override
    public void onCreate(SQLiteDatabase db) {
        //Aqui está sendo gerado todas as suas tabelas e respectivos campos, de acordo com o array TABLE_NAMES e TABLE_FIELDS
        for (int i = 0; i < TABLE_NAMES.length; i++) {
            String CREATE_TABLE = "CREATE TABLE " + TABLE_NAMES[i] + "(";
            for (int y = 0; y < TABLE_FIELDS[i].length; y++) {
                CREATE_TABLE = CREATE_TABLE + TABLE_FIELDS[i][y][0] + " " +TABLE_FIELDS[i][y][1];
                if(y < TABLE_FIELDS[i].length-1){ CREATE_TABLE = CREATE_TABLE +","; }
            }
            CREATE_TABLE = CREATE_TABLE + ")";
            db.execSQL(CREATE_TABLE);
        }
       
        //Aqui está sendo gerado todos os índices das tabelas, estude sobre índices para entender o porque.
        //Deve-se ter cuidado com os índices para que não deixe suas consultas lentas no lugar de otimiza-las
        for (int i = 0; i < TABLE_INDEX.length; i++) {
            for (int x = 1; x <= TABLE_INDEX[i].length; x++) {
                String CREATE_INDEX = "CREATE UNIQUE INDEX index"+Integer.toString(i)+Integer.toString(x)+" ON "+TABLE_NAMES[i]+" ("+TABLE_INDEX[i][x-1]+")";
                db.execSQL(CREATE_INDEX);
            }
        }
    }
   
    //Método que faz o insert de dados nas tabelas
    float insert(String cTabela, String[][] aDados){
        SQLiteDatabase db = this.getWritableDatabase();
        ContentValues cv = new ContentValues();
        for (int i = 0; i < aDados.length; i++) {
            cv.put(aDados[i][0], aDados[i][1]);
        }       
        float r = db.insert(cTabela, null, cv);
        db.close();
        return r;
    }
   
    //Método que faz o update de dados nas tabelas
    void update(String cTabela, String[][] aDados, String cWhere){
        SQLiteDatabase db = this.getWritableDatabase();
        ContentValues cv = new ContentValues();
        for (int i = 0; i < aDados.length; i++) {
            cv.put(aDados[i][0], aDados[i][1]);
        }       
        db.update(cTabela, cv, cWhere, null);
        db.close();
    }
   
    //Método que faz o delete de dados nas tabelas
    public void delete(String cTabela, String cWhere) {
        SQLiteDatabase db = this.getWritableDatabase();
        db.delete(cTabela, cWhere, null);
        db.close();
    }
   
    //Função que irá posicionar o cursor de acordo com o dados informados, como tabela, where, índice a utilizar, etc...
    public Cursor seek(String cTabela, String cWhere, Integer nOrder, String cOrderType){
        SQLiteDatabase db = this.getReadableDatabase();
        //Verifica qual a posição da tabela em questão
        int nPosArray = 0;
        for (int i = 0; i < TABLE_NAMES.length; i++) {
             if(TABLE_NAMES[i]==cTabela){nPosArray = i+1;}
        }
        //Caso a tabela informada não existir
        if(nPosArray!=0){
            nPosArray = nPosArray-1;
            int nTamArray = TABLE_FIELDS[nPosArray].length;
            String cOrder = TABLE_INDEX[nPosArray][nOrder].replaceAll(","," "+cOrderType+",")+" "+cOrderType;
            String[] aCols = new String[nTamArray];
            for (int i = 0; i < nTamArray; i++) {
                aCols[i] = TABLE_FIELDS[nPosArray][i][0];
            }
            c = db.query(cTabela, aCols, cWhere, null, null, null, cOrder);
        }              
        return c;
    }
     
    //Upgrading da base de dados
    //Ao alterar a versão da base de dados ( variável DATABASE_VERSION), automaticamente ao iniciar a aplicação
    //o sistema irá fazer a autilização do seu banco, novas tabelas ou novos campos ou novos índices, etc...
    //O mais importante é que não irá perder os dados já existentes nas tabelas, o fonte abaixo já trata de guarda-los antes de
    //apagar e reconstruir suas tabelas.
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        //ALGUMAS INSTRUÇÕES:
        //- Renomear o campo perde todos os dados desse campo
        //- Renomear tabela perde todos os dados dessa tabela
        //- Adicionar campos nao se perde dados
        //- Adicionar tabela não se perde dados       
       
        //Por segurança, apaga as tabelas temporarias (se ocorreu um erro na ultima atualização)
        for (int i = 0; i < TABLE_NAMES.length; i++) {db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAMES[i]+"_temp");}       
       
        //Cria as tabelas temporarias
        for (int i = 0; i < TABLE_NAMES.length; i++) {
            String CREATE_TABLE = "CREATE TABLE " + TABLE_NAMES[i]+"_temp" + "(";
            for (int y = 0; y < TABLE_FIELDS[i].length; y++) {
                CREATE_TABLE = CREATE_TABLE + TABLE_FIELDS[i][y][0] + " " +TABLE_FIELDS[i][y][1];
                if(y < TABLE_FIELDS[i].length-1){ CREATE_TABLE = CREATE_TABLE +","; }
            }
            CREATE_TABLE = CREATE_TABLE + ")";
            db.execSQL(CREATE_TABLE);
        }
       
        //Copia os dados das tabelas principais para as temporarias
        for (int i = 0; i < TABLE_NAMES.length; i++) {
            //Caso seja uma tabela ja existente e não uma nova tabela
            try{
                Cursor c;
                String INSERT_TABLE = "INSERT INTO " + TABLE_NAMES[i]+"_temp" + "(";
                String INSERT_FIELDS = "";
                boolean bCpos = false;
               
                c = db.query(TABLE_NAMES[i], null, null, null, null, null, null);
                for (int y = 0; y < TABLE_FIELDS[i].length; y++) {
                    if(c.getColumnIndex(TABLE_FIELDS[i][y][0])>0){
                        INSERT_FIELDS = INSERT_FIELDS + TABLE_FIELDS[i][y][0];
                        if(y < TABLE_FIELDS[i].length-1){
                            if(y+1<TABLE_FIELDS[i].length){
                                //Verifica se o proximo campo existe na tabela
                                if(c.getColumnIndex(TABLE_FIELDS[i][y+1][0])>0){
                                    INSERT_FIELDS = INSERT_FIELDS +",";
                                    bCpos = true;
                                }
                            }
                        }
                    }
                }
                c.close();
                //Não executa no caso de manter o nome da tabela e trocar todos os campos  
                if(bCpos){
                    INSERT_TABLE = INSERT_TABLE + INSERT_FIELDS + ") SELECT "+INSERT_FIELDS+" FROM "+TABLE_NAMES[i];
                    db.execSQL(INSERT_TABLE);
                }
            }catch (SQLiteException e) {}
        }
       
        //Apaga as tabelas principais
        for (int i = 0; i < TABLE_NAMES.length; i++) {db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAMES[i]);}
       
        //Recria as tabelas
        onCreate(db);
       
        //Copia os dados das tabelas temporarias para as principais
        for (int i = 0; i < TABLE_NAMES.length; i++) {
            String INSERT_TABLE = "INSERT INTO " + TABLE_NAMES[i] + "(";
            String INSERT_FIELDS = "";
            for (int y = 0; y < TABLE_FIELDS[i].length; y++) {
                INSERT_FIELDS = INSERT_FIELDS + TABLE_FIELDS[i][y][0];
                if(y < TABLE_FIELDS[i].length-1){INSERT_FIELDS = INSERT_FIELDS +",";}
            }
            INSERT_TABLE = INSERT_TABLE + INSERT_FIELDS + ") SELECT "+INSERT_FIELDS+" FROM "+TABLE_NAMES[i]+"_temp";
            db.execSQL(INSERT_TABLE);
        }
       
        //Apaga as tabelas temporarias
        for (int i = 0; i < TABLE_NAMES.length; i++) {db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAMES[i]+"_temp");}
    }
}
 

public DataHelper db = new DataHelper(this);
 

String[][] aDados = {{"campo1","valor"},
{"campo2","valor"},
{"campo3","valor"},
{"campo4","valor"}};
//nIdR será o id do novo registro inserido na base de dados
//esse id é o retorno do campo PRIMARY KEY da tabela, que definimos no inicio da classe
float nIdR = db.insert("tabela1",aDados);
 

//Parâmetro 1: nome ta tabela
//Parâmetro 2: where que irá definir quais registros devem ser excluídos
db.delete("tabela1","campo1='xy'");
 

String[][] aDados = {{"campo2","valor"},
{"campo4","valor"}};
String PK = BaseColumns._ID;

//Parâmetro 1: nome ta tabela
//Parâmetro 2: campos e respectivos valores que serão atualizados
//Parâmetro 3: where que irá definir quais registros devem ser atualizados, nesse caso será um, que terá o primary key = 10
db.update("tabela1",aDados,PK+"='10'");
 

//Parâmetro 1: nome da tabela
//Parâmetro 2: filtro where, se for necessário trazer todos os registros, basta colocar null
//Parâmetro 3: índice a ser utilizado ( foi definido na classe, como é um array, começa a ser contado na posição 0 )
//Parâmetro 4: o cursor deve ser ordenado do menor para o maior de acordo com os campos do índice informado (ASC) ou do maior para o menor (DESC) de acordo com os campos do índice informado.
Cursor CTB1 = db.seek("tabela1", null, 0, "ASC");
CTB1.moveToFirst(); //move o cursor para o primeiro registro encontrado
if(CTB1.getCount()>0){ //verifica se encontrou algum registro
    while (!CTB1.isAfterLast()) { //enquanto existir um registro
        Log.d("DATAHELP",CTB1.getString(CTB1.getColumnIndex("campo1")));
        //Pula para o proximo registro encontrado
        CTB1.moveToNext();
    }
}
CTB1.close();
db.close();