package cn.net.caoyao.cpzshandset.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Build;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * @author Joshua 用法： DBHelper dbHelper = new DBHelper(this);
 * dbHelper.createDataBase(); SQLiteDatabase db =
 * dbHelper.getWritableDatabase(); Cursor cursor = db.query()
 * db.execSQL(sqlString); 注意：execSQL不支持带;的多条SQL语句，只能一条一条的执行，晕了很久才明白
 * 见execSQL的源码注释 (Multiple statements separated by ;s are not
 * supported.) 将把assets下的数据库文件直接复制到DB_PATH，但数据库文件大小限制在1M以下
 * 如果有超过1M的大文件，则需要先分割为N个小文件，然后使用copyBigDatabase()替换copyDatabase()
 */
public class CityDBHelper extends SQLiteOpenHelper {
    // 用户数据库文件的版本
    private static final int DB_VERSION = 5;
    /**
     * 如果数据库文件较大，使用FileSplit分割为小于1M的小文件 此例中分割为 hello.db.101 hello.db.102
     * hello.db.103
     */
    // 第一个文件名后缀
    private static final int ASSETS_SUFFIX_BEGIN = 101;
    /*
     * //如果你想把数据库文件存放在SD卡的话 private static String DB_PATH =
     * android.os.Environment.getExternalStorageDirectory().getAbsolutePath() +
     * "/arthurcn/drivertest/packfiles/";
     */
    // 最后一个文件名后缀
    private static final int ASSETS_SUFFIX_END = 103;
    // 数据库文件目标存放路径为系统默认位置，com.droid 是你的包名
    private static String DB_PATH = "/data/data/cn.net.caoyao.cpzshandset/databases/";
//    public static String tb_address = "cityInfo";//保存用户信息的数据表
    private static String DB_NAME = "city.db";
    private static String ASSETS_NAME = "city.db";
    private final Context myContext;
    private SQLiteDatabase myDataBase = null;

    /**
     * 在SQLiteOpenHelper的子类当中，必须有该构造函数
     *
     * @param context 上下文对象
     * @param name    数据库名称
     * @param factory 一般都是null
     * @param version 当前数据库的版本，值必须是整数并且是递增的状态
     */
    public CityDBHelper(Context context, String name, CursorFactory factory,
                        int version) {
        // 必须通过super调用父类当中的构造函数

        super(context, name, null, version);
        this.myContext = context;
    }

    public CityDBHelper(Context context, String name, int version) {
        this(context, name, null, version);
    }

    public CityDBHelper(Context context, String name) {
        this(context, name, DB_VERSION);
    }

    public CityDBHelper(Context context, boolean enableWAL) {
        this(context, DB_PATH + DB_NAME);
        if (enableWAL && Build.VERSION.SDK_INT >= 11) {
            getWritableDatabase().enableWriteAheadLogging();
        }
    }

    public void createDataBase() throws IOException {

        boolean dbExist = checkDataBase();
        if (dbExist) {
            // 数据库已存在，do nothing.
        } else {
            // 创建数据库
            try {
                File dir = new File(DB_PATH);

                if (!dir.exists()) {
                    dir.mkdirs();
                }
                File dbf = new File(DB_PATH + DB_NAME);
                if (dbf.exists()) {
                    dbf.delete();
                }
                SQLiteDatabase.openOrCreateDatabase(dbf, null);
                // 复制asseets中的db文件到DB_PATH下
                copyDataBase();
            } catch (IOException e) {
                throw new Error("数据库创建失败");
            }
        }
    }

    public void createDb(){
        // 创建数据库
        try {
            File dir = new File(DB_PATH);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            File dbf = new File(DB_PATH + DB_NAME);
            if (dbf.exists()) {
                dbf.delete();
            }
            SQLiteDatabase.openOrCreateDatabase(dbf, null);
            // 复制asseets中的db文件到DB_PATH下
            copyDataBase();
        } catch (IOException e) {
            throw new Error("数据库创建失败");
        }
    }
    // 检查数据库是否有效
    //SQLiteDatabase.openDatabase:有些版本不支持
    /*private boolean checkDataBase() {
		SQLiteDatabase checkDB = null;
		String myPath = DB_PATH + DB_NAME;
		try {

			checkDB = SQLiteDatabase.openDatabase(myPath, null,
					SQLiteDatabase.OPEN_READONLY);
		} catch (SQLiteException e) {
			// database does't exist yet.
		}
		if (checkDB != null) {
			checkDB.close();
		}
		return checkDB != null ? true : false;
	}*/

    /**
     * 检测数据库是否存在,若当前文件存在，则说明该数据库是存在的，否则，数据库不存在
     *
     * @return
     */
    private boolean checkDataBase() {
        String myPath = DB_PATH + DB_NAME;
        File dbFile = myContext.getDatabasePath(myPath);
        File shm = myContext.getDatabasePath(DB_PATH + "city.db-shm");
        File wal = myContext.getDatabasePath(DB_PATH + "city.db-wal");
        if (shm.exists()) {
            shm.delete();
        }
        if (wal.exists()) {
            wal.delete();
        }
        return dbFile.exists();
    }

    /**
     * Copies your database from your local assets-folder to the just created
     * empty database in the system folder, from where it can be accessed and
     * handled. This is done by transfering bytestream.
     */
    private void copyDataBase() throws IOException {
        // Open your local db as the input stream
        InputStream myInput = myContext.getAssets().open(ASSETS_NAME);
        // Path to the just created empty db
        String outFileName = DB_PATH + DB_NAME;
        // Open the empty db as the output stream
        OutputStream myOutput = new FileOutputStream(outFileName);
        // transfer bytes from the inputfile to the outputfile
        byte[] buffer = new byte[1024];
        int length;
        while ((length = myInput.read(buffer)) > 0) {
            myOutput.write(buffer, 0, length);
        }
        // Close the streams
        myOutput.flush();
        myOutput.close();
        myInput.close();
    }

    // 复制assets下的大数据库文件时用这个
    @SuppressWarnings("unused")
    private void copyBigDataBase() throws IOException {
        InputStream myInput;
        String outFileName = DB_PATH + DB_NAME;
        OutputStream myOutput = new FileOutputStream(outFileName);
        for (int i = ASSETS_SUFFIX_BEGIN; i < ASSETS_SUFFIX_END + 1; i++) {
            myInput = myContext.getAssets().open(ASSETS_NAME + "." + i);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = myInput.read(buffer)) > 0) {
                myOutput.write(buffer, 0, length);
            }
            myOutput.flush();
            myInput.close();
        }
        myOutput.close();
    }

    @Override
    public synchronized void close() {
        if (myDataBase != null) {
            myDataBase.close();
        }
        super.close();
    }

    /**
     * 该函数是在第一次创建的时候执行， 实际上是第一次得到SQLiteDatabase对象的时候才会调用这个方法
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        //创建地址信息表 [id] INT,
        //  [province] CHAR,
        //  [city] CHAR,
        //  [area] CHAR)


    }

    @Override
    public void onOpen(SQLiteDatabase db) {
        super.onOpen(db);
    }

    /**
     * 数据库表结构有变化时采用
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    }

}