import sqlite3, {Database} from "sqlite3";
import path from "path";
import os from "os";
import fs from "fs";

/**
 * @brief 设置续传缓存机制
 */
export default class CheckCache{
    /**
     * @breif 创建表信息
     */
    private static sql_create_table = 'create table check_cache ('
        + 'plain_sha varchar PRIMARY KEY NOT NULL unique,'
        + 'md5 varchar,'
        + 'media_id varchar,'
        + 'file_size mediumint,'
        + 'object_key varchar,'
        + 'part_size mediumint,'
        + 'upload_id varchar,'
        + 'key_value varchar,'
        + 'iv_value varchar,'
        + 'storage_time varchar)';
    private static sql_insert_status = 'insert into check_cache '
        + '(plain_sha,md5, media_id, file_size, object_key, part_size, upload_id, key_value, iv_value, storage_time)'
        + 'values (?,?,?,?,?,?,?,?,?,?)';
    /**
     * @brief 删除逻辑
     * */
    private static sql_delete_status = 'delete from check_cache where plain_sha = ?';
    /**
     * @brief 批量删除
     * 删除所有小于这个时间的
     * */
    private static sql_deletes_status = 'delete from check_cache where storage_time < ?';
    /**
     * @breif 查询逻辑
     * */
    private static sql_query_status = 'select md5, media_id, file_size, object_key, part_size, upload_id, key_value, iv_value, storage_time from check_cache where plain_sha = ?';
    /**
     * @brief 自动查询最小值语句
     * */
    private static sql_querymin_status = 'select min(storage_time) from check_cache';

    private _db: Database;

    private constructor(db: sqlite3.Database) {
        this._db = db;
    }

    static async build() {
        let dbDir = path.join(os.tmpdir(), 'wl_cache/');
        let dbfile = path.join(dbDir, 'index.db');
        //console.log("The database file:" + dbfile + " will be created.");
        //确保目录存在
        if (!fs.existsSync(dbDir)) {
            fs.mkdirSync(dbDir);
        }

        let db = await CheckCache.initdb(dbfile);
        let obj = new CheckCache(db);
        return obj;
    }

    /**
     *  @brief 触发器 设置数据库自动过期
     *
    * */
    private static initdb(dbfile: string) {
        return new Promise<sqlite3.Database>((resolve, reject) => {
            let db = new sqlite3.Database(dbfile, err => {
                if (err !== null) {
                    //console.error(dbfile + ' open failure!');
                    reject(err);
                }

                let sql = CheckCache.sql_create_table;

                db.run(sql, e => {
                    if (e !== null) {
                        if ((e as any).errno === 1) {
                            //console.debug(e.message);
                            resolve(db);
                        } else {
                            reject(e);
                        }
                    } else {
                        resolve(db);
                    }
                })
            })
        });
    }

    insert(bucket: CheckBucket) {
        return new Promise((resolve, reject) => {
            let sql = CheckCache.sql_insert_status;

            let values: any[] = [
                bucket.plain_sha,
                bucket.md5,
                bucket.media_id,
                bucket.file_size,
                bucket.object_key,
                bucket.part_size,
                bucket.upload_id,
                bucket.key_value,
                bucket.iv_value,
                bucket.storage_time
            ];

            this._db.run(sql, values, e => {
                if (e !== null) reject(e);
                else resolve(this);
            });
        });
    }

    delete(sha: string) {
        return new Promise((resolve, reject) => {
            let sql = CheckCache.sql_delete_status;
            this._db.get(sql, sha, e => {
                if (e !== null) reject(e);
                else {
                    resolve(this);
                };
            })
        });
    }

    /**
     * @breif 批量删除函数
     * */
    deletes(delectTime: number) {
       let failure_time = delectTime;// - (7 * 24 * 60 * 60 * 60);
        return new Promise((resolve, reject) => {
            let sql = CheckCache.sql_deletes_status;
            this._db.get(sql, failure_time, e => {
                if (e !== null) reject(e);
                else {
                    resolve(this);
                };
            })
        });
    }

    query(sha: string) {
        return new Promise<CheckBucket | undefined>((resolve, reject) => {
            let sql = CheckCache.sql_query_status;
            this._db.get(sql, sha, (e, row) => {
                if (e !== null) reject(e);
                else {
                    resolve(row);
                }
            })
        });
    }

    querymin() {
        return new Promise<CheckBucket | undefined>((resolve, reject) => {
            let sql = CheckCache.sql_querymin_status;
            this._db.get(sql, (e, row) => {
                if (e !== null) reject(e);
                else {
                    resolve(row);
                }
            })
        });
    }


}

/** 续传信息 */
export interface CheckBucket {
    plain_sha: string;
    md5: string;
    media_id: string;
    file_size: string;
    object_key: string;
    part_size: string;
    upload_id: string;
    key_value: string;
    iv_value: string;
    storage_time: string;
}