df-fields 0.1.16

use std::time::{Duration, UNIX_EPOCH};
use json::{JsonValue, object};
use crate::Field;
use chrono::{DateTime, Local, NaiveDate, NaiveDateTime};

pub struct Year {
    pub require: bool,
    pub field: String,
    pub mode: String,
    pub title: String,
    pub def: u64,
}

impl Year {
    pub fn new(require: bool, field: &str, title: &str, default: u64) -> Self {
        Self {
            field: field.to_string(),
            mode: "year".to_string(),
            title: title.to_string(),
            def: default,
            require,
        }
    }
    pub fn year() -> String {
        let now: DateTime<Local> = Local::now();
        let dft = now.format("%Y");
        dft.to_string()
    }
    pub fn timestamp_to_year(timestamp: i64) -> String {
        let d = UNIX_EPOCH + Duration::from_secs(timestamp as u64);
        let datetime = DateTime::<Local>::from(d);
        let timestamp_str = datetime.format("%Y").to_string();
        timestamp_str
    }
}

impl Field for Year {
    fn sql(&mut self, model: &str) -> String {
        let mut sql = format!("{}", self.field);
        sql = format!("{} year", sql.clone());
        if self.require {
            sql = format!("{} not null default '{}'", sql.clone(), self.def);
        } else {
            sql = format!("{} null", sql.clone())
        }
        match model {
            "sqlite" => sql,
            _ => format!("{} comment '{}|{}|{}|{}'", sql.clone(), self.title, self.mode, self.require, self.def)
        }
    }
    fn field(&mut self) -> JsonValue {
        let mut field = object! {};
        field.insert("require", JsonValue::from(self.require.clone())).unwrap();
        field.insert("field", JsonValue::from(self.field.clone())).unwrap();
        field.insert("mode", JsonValue::from(self.mode.clone())).unwrap();
        field.insert("title", JsonValue::from(self.title.clone())).unwrap();
        field.insert("def", JsonValue::from(self.def.clone())).unwrap();
        field
    }
}


pub struct Datetime {
    pub require: bool,
    pub field: String,
    pub mode: String,
    pub title: String,
    pub def: String,
}

impl Datetime {
    pub fn new(require: bool, field: &str, title: &str, mut default: &str) -> Self {
        if default == "" {
            default = "0000-01-01 00:00:00"
        }
        Self {
            field: field.to_string(),
            mode: "datetime".to_string(),
            title: title.to_string(),
            def: default.to_string(),
            require,
        }
    }
    pub fn datetime() -> String {
        let now: DateTime<Local> = Local::now();
        let dft = now.format("%Y-%m-%d %H:%M:%S");
        dft.to_string()
    }
    pub fn timestamp_to_datetime(timestamp: i64) -> String {
        let d = UNIX_EPOCH + Duration::from_secs(timestamp as u64);
        let datetime = DateTime::<Local>::from(d);
        let timestamp_str = datetime.format("%Y-%m-%d %H:%M:%S").to_string();
        timestamp_str
    }
}

impl Field for Datetime {
    fn sql(&mut self, model: &str) -> String {
        let mut sql = format!("{}", self.field);
        sql = format!("{} datetime", sql.clone());
        if self.require {
            sql = format!("{} not null default '{}'", sql.clone(), self.def);
        } else {
            sql = format!("{} null", sql.clone())
        }
        match model {
            "sqlite" => sql,
            _ => format!("{} comment '{}|{}|{}|{}'", sql.clone(), self.title, self.mode, self.require, self.def)
        }
    }
    fn field(&mut self) -> JsonValue {
        let mut field = object! {};
        field.insert("require", JsonValue::from(self.require.clone())).unwrap();
        field.insert("field", JsonValue::from(self.field.clone())).unwrap();
        field.insert("mode", JsonValue::from(self.mode.clone())).unwrap();
        field.insert("title", JsonValue::from(self.title.clone())).unwrap();
        field.insert("def", JsonValue::from(self.def.clone())).unwrap();
        field
    }
}


pub struct Time {
    pub require: bool,
    pub field: String,
    pub mode: String,
    pub title: String,
    pub def: String,
}

impl Time {
    pub fn new(require: bool, field: &str, title: &str, default: &str) -> Self {
        Self {
            field: field.to_string(),
            mode: "time".to_string(),
            title: title.to_string(),
            def: default.to_string(),
            require,
        }
    }
    pub fn time() -> String {
        let now: DateTime<Local> = Local::now();
        let dft = now.format("%H:%M:%S");
        dft.to_string()
    }
}

impl Field for Time {
    fn sql(&mut self, model: &str) -> String {
        let mut sql = format!("{}", self.field);
        sql = format!("{} time", sql.clone());
        if self.require {
            sql = format!("{} not null default '{}'", sql.clone(), self.def);
        } else {
            sql = format!("{} null", sql.clone())
        }
        match model {
            "sqlite" => sql,
            _ => format!("{} comment '{}|{}|{}|{}'", sql.clone(), self.title, self.mode, self.require, self.def)
        }
    }
    fn field(&mut self) -> JsonValue {
        let mut field = object! {};
        field.insert("require", JsonValue::from(self.require.clone())).unwrap();
        field.insert("field", JsonValue::from(self.field.clone())).unwrap();
        field.insert("mode", JsonValue::from(self.mode.clone())).unwrap();
        field.insert("title", JsonValue::from(self.title.clone())).unwrap();
        field.insert("def", JsonValue::from(self.def.clone())).unwrap();
        field
    }
}


pub struct Date {
    pub require: bool,
    pub field: String,
    pub mode: String,
    pub title: String,
    pub def: String,
}

impl Date {
    pub fn new(require: bool, field: &str, title: &str, default: &str) -> Self {
        let def = {
            if default == "" {
                "0000-01-01"
            } else {
                default
            }
        };
        Self {
            field: field.to_string(),
            mode: "date".to_string(),
            title: title.to_string(),
            def: def.parse().unwrap(),
            require,
        }
    }
    /// 默认值 2023-01-01
    pub fn date() -> String {
        let now: DateTime<Local> = Local::now();
        let dft = now.format("%Y-%m-%d");
        dft.to_string()
    }
    pub fn timestamp_to_date(timestamp: i64) -> String {
        let d = UNIX_EPOCH + Duration::from_secs(timestamp as u64);
        let datetime = DateTime::<Local>::from(d);
        let timestamp_str = datetime.format("%Y-%m-%d").to_string();
        timestamp_str
    }
}

impl Field for Date {
    fn sql(&mut self, model: &str) -> String {
        let mut sql = format!("{}", self.field);
        sql = format!("{} date", sql.clone());
        if self.require {
            sql = format!("{} not null default '{}'", sql.clone(), self.def);
        } else {
            sql = format!("{} null", sql.clone())
        }
        match model {
            "sqlite" => sql,
            _ => format!("{} comment '{}|{}|{}|{}'", sql.clone(), self.title, self.mode, self.require, self.def)
        }
    }
    fn field(&mut self) -> JsonValue {
        let mut field = object! {};
        field.insert("require", JsonValue::from(self.require.clone())).unwrap();
        field.insert("field", JsonValue::from(self.field.clone())).unwrap();
        field.insert("mode", JsonValue::from(self.mode.clone())).unwrap();
        field.insert("title", JsonValue::from(self.title.clone())).unwrap();
        field.insert("def", JsonValue::from(self.def.clone())).unwrap();
        field
    }
}


pub struct Timestamp {
    pub require: bool,
    pub field: String,
    pub mode: String,
    pub title: String,
    pub def: f64,
    pub dec: i32,
}

impl Timestamp {
    pub fn new(require: bool, field: &str, title: &str, dec: i32, default: f64) -> Self {
        Self {
            require,
            field: field.to_string(),
            mode: "timestamp".to_string(),
            title: title.to_string(),
            def: default,
            dec,
        }
    }
    /// 默认值 秒 10位
    pub fn timestamp() -> i64 {
        return Local::now().timestamp();
    }
    /// 毫秒 13位
    pub fn timestamp_ms() -> i64 {
        return Local::now().timestamp_millis();
    }
    /// 毫秒 10位+3位
    pub fn timestamp_ms_f64() -> f64 {
        return Local::now().timestamp_millis() as f64 / 1000.0;
    }
    /// 微秒 16位
    pub fn timestamp_μs() -> i64 {
        return Local::now().timestamp_micros();
    }
    /// 微秒 16位
    pub fn timestamp_μs_f64() -> f64 {
        return Local::now().timestamp_micros() as f64 / 1000.0 / 1000.0;
    }
    /// 纳秒 19位
    pub fn timestamp_ns() -> i64 {
        return Local::now().timestamp_nanos();
    }

    /// 日期转时间戳
    pub fn date_to_timestamp(date: &str) -> i64 {
        let t = NaiveDate::parse_from_str(date, "%Y-%m-%d").unwrap();
        return t.and_hms_opt(0, 0, 0).unwrap().timestamp();
    }
    /// 日期时间转时间戳
    pub fn datetime_to_timestamp(datetime: &str) -> i64 {
        let t = NaiveDateTime::parse_from_str(datetime, "%Y-%m-%d %H:%M:%S").unwrap();
        return t.timestamp();
    }
}

impl Field for Timestamp {
    fn sql(&mut self, model: &str) -> String {
        let max = 10 + self.dec;

        let mut sql = format!("{}", self.field);
        sql = format!("{} float({},{})", sql.clone(), max, self.dec);
        if self.require {
            sql = format!("{} not null", sql.clone())
        };
        self.def = format!("{0:.width$}", self.def, width = self.dec as usize).parse::<f64>().unwrap();
        sql = format!("{} default {}", sql.clone(), self.def);
        match model {
            "sqlite" => sql,
            _ => format!("{} comment '{}|{}|{}|{}|{}'", sql.clone(), self.title, self.mode, self.require, self.dec, self.def)
        }
    }
    fn field(&mut self) -> JsonValue {
        let mut field = object! {};
        field.insert("require", JsonValue::from(self.require.clone())).unwrap();
        field.insert("field", JsonValue::from(self.field.clone())).unwrap();
        field.insert("mode", JsonValue::from(self.mode.clone())).unwrap();
        field.insert("title", JsonValue::from(self.title.clone())).unwrap();
        field.insert("def", JsonValue::from(self.def.clone())).unwrap();
        field.insert("dec", JsonValue::from(self.dec.clone())).unwrap();
        field
    }
}