df-db 0.1.7

use json::{array, JsonValue, object};
use crate::config::{Config, Params};
use crate::mode::Mode;
use crate::mode::mysql::Mysql;
use crate::mode::sqlite::Sqlite;
use crate::mode::mssql::Mssql;
use crate::model::ModelTable;

pub struct Db {}

impl Db {
    pub fn new(conf: JsonValue) -> ModeDb {
        if conf.is_empty() {
            return ModeDb::None;
        }
        let default = conf["default"].to_string();
        let config = conf["connections"][default].clone();
        let mut params = vec![];
        for item in config["params"].members() {
            params.push(item.to_string());
        }

        let mode = {
            if config["mode"].is_empty() {
                "sqlite"
            } else {
                config["mode"].as_str().unwrap()
            }
        };
        let config = Config {
            db_mode: Mode::from(mode),
            keyauto: config["keyauto"].as_bool().unwrap(),
            hostname: config["hostname"].to_string(),
            hostport: config["hostport"].to_string(),
            database: config["database"].to_string(),
            username: config["username"].to_string(),
            userpass: config["userpass"].to_string(),
            charset: config["charset"].to_string(),
            prefix: config["prefix"].to_string(),
            params: params.clone(),
            debug: config["debug"].as_bool().unwrap(),
        };
        match config.db_mode {
            Mode::Mysql => {
                ModeDb::Mysql(Mysql::connect(config.clone(), Mode::Mysql))
            }
            Mode::Mssql => {
                ModeDb::Mssql(Mssql {
                    config: config.clone(),
                    params: Params::default(Mode::Mssql),
                })
            }
            Mode::Sqlite => {
                ModeDb::Sqlite(Sqlite::connect(config.clone(), Mode::Sqlite))
            }
        }
    }
}

pub enum ModeDb {
    Mysql(Mysql),
    Mssql(Mssql),
    Sqlite(Sqlite),
    None,
}

pub trait Request {
    fn table_create(&mut self, data: ModelTable) -> bool;
    fn table_update(&mut self, data: ModelTable) -> bool;
    fn table_info(&mut self, table: &str) -> JsonValue;
    fn table_is_exist(&mut self, name: &str) -> bool;
    fn table(&mut self, name: &str) -> &mut Self;
    /// 排序
    fn order(&mut self, field: &str, by: bool) -> &mut Self;
    /// 分组
    fn group(&mut self, field: &str) -> &mut Self;
    /// 消除重复记录
    fn distinct(&mut self, distinct: bool) -> &mut Self;
    /// JSON 字段
    fn json(&mut self, field: &str) -> &mut Self;
    /// 查询指定列并返回数组
    fn column(&mut self, field: &str) -> JsonValue;

    fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self;
    fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self;

    fn count(&mut self) -> i64;
    fn max(&mut self, field: &str) -> JsonValue;
    fn min(&mut self, field: &str) -> JsonValue;
    fn sum(&mut self, field: &str) -> JsonValue;
    fn avg(&mut self, field: &str) -> JsonValue;
    fn select(&mut self) -> JsonValue;
    fn find(&mut self) -> JsonValue;
    fn insert(&mut self, data: JsonValue) -> i32;
    fn insert_all(&mut self, data: JsonValue) -> JsonValue;
    fn page(&mut self, page: i32, limit: i32) -> &mut Self;
    fn update(&mut self, data: JsonValue) -> i32;
    fn delete(&mut self) -> i32;
    fn field(&mut self, name: &str) -> &mut Self;

    /// 事务开始
    fn transaction(&mut self) -> bool;
    /// 事务提交
    fn commit(&mut self) -> bool;
    /// 事务回滚
    fn rollback(&mut self) -> bool;
}

impl Request for ModeDb {
    fn table(&mut self, name: &str) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.table(name);
            }
            ModeDb::Sqlite(db) => {
                db.table(name);
            }
            ModeDb::Mssql(db) => {
                db.table(name);
            }
            _ => {}
        };
        self
    }
    fn table_create(&mut self, data: ModelTable) -> bool {
        match self {
            ModeDb::Mysql(db) => {
                db.table_create(data)
            }
            ModeDb::Sqlite(db) => {
                db.table_create(data)
            }
            ModeDb::Mssql(db) => {
                db.table_create(data)
            }
            _ => false
        }
    }

    fn table_update(&mut self, data: ModelTable) -> bool {
        match self {
            ModeDb::Mysql(db) => {
                db.table_update(data)
            }
            ModeDb::Sqlite(db) => {
                db.table_update(data)
            }
            ModeDb::Mssql(db) => {
                db.table_update(data)
            }
            _ => false
        }
    }

    fn table_info(&mut self, table: &str) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.table_info(table)
            }
            ModeDb::Sqlite(db) => {
                db.table_info(table)
            }
            ModeDb::Mssql(db) => {
                db.table_info(table)
            }
            _ => object! {}
        }
    }

    fn table_is_exist(&mut self, name: &str) -> bool {
        match self {
            ModeDb::Mysql(db) => {
                db.table_is_exist(name)
            }
            ModeDb::Sqlite(db) => {
                db.table_is_exist(name)
            }
            ModeDb::Mssql(db) => {
                db.table_is_exist(name)
            }
            _ => false
        }
    }

    /// 排序
    ///
    /// * field 排序字段
    /// * by 排序方法 true 降序 false 升序
    fn order(&mut self, field: &str, by: bool) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.order(field, by);
            }
            ModeDb::Sqlite(db) => {
                db.order(field, by);
            }
            ModeDb::Mssql(db) => {
                db.order(field, by);
            }
            _ => {}
        }
        self
    }

    fn group(&mut self, field: &str) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.group(field);
            }
            ModeDb::Sqlite(db) => {
                db.group(field);
            }
            ModeDb::Mssql(db) => {
                db.group(field);
            }
            _ => {}
        }
        self
    }

    fn distinct(&mut self, distinct: bool) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.distinct(distinct);
            }
            ModeDb::Sqlite(db) => {
                db.distinct(distinct);
            }
            ModeDb::Mssql(db) => {
                db.distinct(distinct);
            }
            _ => {}
        }
        self
    }

    fn json(&mut self, field: &str) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.json(field);
            }
            ModeDb::Sqlite(db) => {
                db.json(field);
            }
            ModeDb::Mssql(db) => {
                db.json(field);
            }
            _ => {}
        }
        self
    }

    fn column(&mut self, field: &str) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.column(field)
            }
            ModeDb::Sqlite(db) => {
                db.column(field)
            }
            ModeDb::Mssql(db) => {
                db.column(field)
            }
            _ => object! {}
        }
    }

    fn where_and(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
        if field.contains("|") {
            let fields: Vec<&str> = field.split("|").collect();
            for field in fields.iter() {
                self.where_and(field, compare, value.clone());
            }
            return self;
        }
        let compare = compare.to_lowercase();
        let compare = compare.replace(" ", "");
        let compare = compare.as_str();
        match self {
            ModeDb::Mysql(db) => {
                db.where_and(field.clone(), compare.clone(), value);
            }
            ModeDb::Sqlite(db) => {
                db.where_and(field.clone(), compare.clone(), value);
            }
            ModeDb::Mssql(db) => {
                db.where_and(field.clone(), compare.clone(), value);
            }
            _ => {}
        };
        self
    }

    fn where_or(&mut self, field: &str, compare: &str, value: JsonValue) -> &mut Self {
        if field.contains("|") {
            let fields: Vec<&str> = field.split("|").collect();
            for field in fields.iter() {
                self.where_or(field, compare, value.clone());
            }
            return self;
        }
        let compare = compare.to_lowercase();
        let compare = compare.replace(" ", "");
        let compare = compare.as_str();
        match self {
            ModeDb::Mysql(db) => {
                db.where_or(field.clone(), compare.clone(), value);
            }
            ModeDb::Sqlite(db) => {
                db.where_or(field.clone(), compare.clone(), value);
            }
            ModeDb::Mssql(db) => {
                db.where_or(field.clone(), compare.clone(), value);
            }
            _ => {}
        };
        self
    }

    fn count(&mut self) -> i64 {
        match self {
            ModeDb::Mysql(db) => {
                db.count()
            }
            ModeDb::Sqlite(db) => {
                db.count()
            }
            ModeDb::Mssql(db) => {
                db.count()
            }
            _ => 0
        }
    }

    fn max(&mut self, field: &str) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.max(field)
            }
            ModeDb::Sqlite(db) => {
                db.max(field)
            }
            ModeDb::Mssql(db) => {
                db.max(field)
            }
            _ => object! {}
        }
    }

    fn min(&mut self, field: &str) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.min(field)
            }
            ModeDb::Sqlite(db) => {
                db.min(field)
            }
            ModeDb::Mssql(db) => {
                db.min(field)
            }
            _ => object! {}
        }
    }

    fn sum(&mut self, field: &str) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.sum(field)
            }
            ModeDb::Sqlite(db) => {
                db.sum(field)
            }
            ModeDb::Mssql(db) => {
                db.sum(field)
            }
            _ => object! {}
        }
    }
    fn avg(&mut self, field: &str) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.avg(field)
            }
            ModeDb::Sqlite(db) => {
                db.avg(field)
            }
            ModeDb::Mssql(db) => {
                db.avg(field)
            }
            _ => object! {}
        }
    }

    fn select(&mut self) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.select()
            }
            ModeDb::Sqlite(db) => {
                db.select()
            }
            ModeDb::Mssql(db) => {
                db.select()
            }
            _ => object! {}
        }
    }

    fn find(&mut self) -> JsonValue {
        match self {
            ModeDb::Mysql(db) => {
                db.find()
            }
            ModeDb::Sqlite(db) => {
                db.find()
            }
            ModeDb::Mssql(db) => {
                db.find()
            }
            _ => object! {}
        }
    }

    fn insert(&mut self, data: JsonValue) -> i32 {
        match self {
            ModeDb::Mysql(db) => {
                db.insert(data.clone())
            }
            ModeDb::Sqlite(db) => {
                db.insert(data.clone())
            }
            ModeDb::Mssql(db) => {
                db.insert(data.clone())
            }
            _ => 0
        }
    }

    fn insert_all(&mut self, mut data: JsonValue) -> JsonValue {
        if data[0].is_empty() {
            data = array![data].into();
        }
        match self {
            ModeDb::Mysql(db) => {
                db.insert_all(data.clone())
            }
            ModeDb::Sqlite(db) => {
                db.insert_all(data.clone())
            }
            ModeDb::Mssql(db) => {
                db.insert_all(data.clone())
            }
            _ => object! {}
        }
    }

    fn page(&mut self, page: i32, limit: i32) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.page(page.clone(), limit.clone());
            }
            ModeDb::Sqlite(db) => {
                db.page(page.clone(), limit.clone());
            }
            ModeDb::Mssql(db) => {
                db.page(page.clone(), limit.clone());
            }
            _ => {}
        };
        self
    }

    fn update(&mut self, data: JsonValue) -> i32 {
        match self {
            ModeDb::Mysql(db) => {
                db.update(data.clone())
            }
            ModeDb::Sqlite(db) => {
                db.update(data.clone())
            }
            ModeDb::Mssql(db) => {
                db.update(data.clone())
            }
            _ => 0
        }
    }

    fn delete(&mut self) -> i32 {
        match self {
            ModeDb::Mysql(db) => {
                db.delete()
            }
            ModeDb::Sqlite(db) => {
                db.delete()
            }
            ModeDb::Mssql(db) => {
                db.delete()
            }
            _ => 0
        }
    }

    fn field(&mut self, name: &str) -> &mut Self {
        match self {
            ModeDb::Mysql(db) => {
                db.field(name.clone());
            }
            ModeDb::Sqlite(db) => {
                db.field(name.clone());
            }
            ModeDb::Mssql(db) => {
                db.field(name.clone());
            }
            _ => {}
        };
        self
    }

    fn transaction(&mut self) -> bool {
        match self {
            ModeDb::Mysql(db) => {
                db.transaction()
            }
            ModeDb::Sqlite(db) => {
                db.transaction()
            }
            ModeDb::Mssql(db) => {
                db.transaction()
            }
            _ => false
        }
    }

    fn commit(&mut self) -> bool {
        match self {
            ModeDb::Mysql(db) => {
                db.commit()
            }
            ModeDb::Sqlite(db) => {
                db.commit()
            }
            ModeDb::Mssql(db) => {
                db.commit()
            }
            _ => false
        }
    }
    fn rollback(&mut self) -> bool {
        match self {
            ModeDb::Mysql(db) => {
                db.rollback()
            }
            ModeDb::Sqlite(db) => {
                db.rollback()
            }
            ModeDb::Mssql(db) => {
                db.rollback()
            }
            _ => false
        }
    }
}