use std::{collections::HashMap, f64};

use serde_derive::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum JsonValue {
    Int(i64),
    Float64(f64),
    String(String),
}

impl Clone for JsonValue {
    fn clone(&self) -> Self {
        match self {
            JsonValue::Int(i) => JsonValue::Int(*i),
            JsonValue::String(s) => JsonValue::String(s.clone()),
            JsonValue::Float64(f) => JsonValue::Float64(*f),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct Dataset {
    pub r#type: DatasetType,
    pub source: String,
}

#[derive(Serialize, Deserialize)]
pub enum DatasetType {
    #[serde(rename = "table")]
    Table,
    #[serde(rename = "view)")]
    View,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DSL {
    pub workflow: Vec<Workflow>,
    pub limit: Option<i64>,
    pub offset: Option<i64>,
    #[serde(default)]
    pub dataview: Vec<DataView>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DataView {
    #[serde(rename = "type")]
    pub workflow_type: DataViewType,
    #[serde(default)]
    pub query: Vec<DataViewQuery>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum DataViewType {
    #[serde(rename = "sql")]
    Sql,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DataViewQuery {
    pub sql: String,
    #[serde(rename = "fidMap")]
    pub fid_pap: HashMap<String, String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Workflow {
    #[serde(rename = "type")]
    pub workflow_type: WorkflowType,
    #[serde(default)]
    pub query: Vec<Query>,
    #[serde(default)]
    pub sort: Sort,
    #[serde(default)]
    pub by: Vec<String>,
    #[serde(default)]
    pub filters: Vec<Filter>,
    #[serde(default)]
    pub transform: Vec<Transform>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Transform {
    pub expression: Expression,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Expression {
    pub op: TransformOp,
    #[serde(rename = "as")]
    pub as_field_key: String,
    pub num: Option<i64>,
    pub params: Option<Vec<ExpParameter>>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum TransformOp {
    #[serde(rename = "one")]
    One,
    #[serde(rename = "bin")]
    Bin,
    #[serde(rename = "binCount")]
    BinCount,
    #[serde(rename = "log2")]
    Log2,
    #[serde(rename = "log10")]
    Log10,
    #[serde(rename = "log")]
    Log,
    #[serde(rename = "dateTimeDrill")]
    DateTimeDrill,
    #[serde(rename = "dateTimeFeature")]
    DateTimeFeature,
    #[serde(rename = "expr")]
    Expr,
    #[serde(rename = "paint")]
    Paint,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ExpParameter {
    #[serde(rename = "type")]
    pub r#type: String,
    pub value: ValueParam,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ValueParam {
    Map(MapParameter),
    String(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MapParameter {
    pub x: String,
    pub y: String,
    pub domain_x: Vec<f64>,
    pub domain_y: Vec<f64>,
    pub map: String,
    pub dict: HashMap<String, Dict>,
    pub mapwidth: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Dict {
    pub name: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Filter {
    #[serde(default)]
    pub fid: String,
    #[serde(default)]
    pub key: String,
    pub rule: Rule,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Rule {
    #[serde(rename = "type")]
    pub rule_type: RuleType,
    pub value: Vec<JsonValue>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum RuleType {
    #[serde(rename = "range")]
    Range,
    #[serde(rename = "one of")]
    OneOf,
    #[serde(rename = "temporal range")]
    Temporal,
}

#[derive(Default, Clone, Debug, Serialize, Deserialize, PartialEq)]
pub enum Sort {
    #[serde(rename = "ascending")]
    Asc,
    #[serde(rename = "descending")]
    Desc,
    #[serde(rename = "")]
    #[default]
    None,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum WorkflowType {
    #[serde(rename = "view")]
    View,
    #[serde(rename = "filter")]
    Filter,
    #[serde(rename = "transform")]
    Transform,
    #[serde(rename = "sort")]
    Sort,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Query {
    pub op: QueryOperation,
    #[serde(default)]
    pub group_by: Vec<String>,
    #[serde(default)]
    pub measures: Vec<Measure>,
    #[serde(default)]
    pub fields: Vec<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum QueryOperation {
    #[serde(rename = "aggregate")]
    Aggregate,
    #[serde(rename = "raw")]
    Raw,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Measure {
    pub field: String,
    pub agg: Agg,
    #[serde(default)]
    #[serde(rename = "asFieldKey")]
    pub as_field_key: String,
    pub format: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum Agg {
    #[serde(rename = "sum")]
    Sum,
    #[serde(rename = "count")]
    Count,
    #[serde(rename = "min")]
    Min,
    #[serde(rename = "max")]
    Max,
    #[serde(rename = "median")]
    Median,
    #[serde(rename = "variance")]
    Variance,
    #[serde(rename = "stdev")]
    StdDev,
    #[serde(rename = "mean")]
    Mean,
    #[serde(rename = "distinctCount")]
    DistinctCount,
    #[serde(rename = "")]
    None,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Rect {
    pub x1: usize,
    pub y1: usize,
    pub x2: usize,
    pub y2: usize,
    pub value: u8,
}