use std::str::FromStr;
use std::collections::HashMap;
use ast::{ModelicaCode, ModelicaPackage, ModelicaBlock, ModelicaConnector,
    ModelicaType, ModelicaModel, ComponentDeclaration, ModelicaRecord,
    ComponentClause, ComponentPrefix, Connection, SimpleEquation, Expr,
    BinOperator, MathUnaryFunc, collapse_components};

// This is an incomplete, non-standards-compliant, minimum-viable parser
// Based on the Modelica 3.3r1 Spec


grammar;


// === Lexical Tokens ===
// Roughly (but possibly not exactly) follows B.1

pub identifier: String = {
    r"[a-zA-Z_][a-zA-Z_0-9]*" => <>.to_string(),
    r"[a-zA-Z_][a-zA-Z_0-9]*\.[a-zA-Z_0-9]+" => <>.to_string(),
    r"[a-zA-Z_][a-zA-Z_0-9]*\.[a-zA-Z_0-9]+\.[a-zA-Z_0-9]" => <>.to_string(),
};

string_literal: String = {
    r#""[^"\\]*""# => <>.to_string(),
};

pub integer: i64 = {
    r"[+-]?\d+" => i64::from_str(<>).unwrap(),
};

pub float: f64 = {
    r"[+-]?\d+\.\d*([eE][-+]?\d+)?" => f64::from_str(<>).unwrap(),
};

pub boolean: bool = {
    "true" => true,
    "false" => false,
};

// Grammar

pub file: Vec<ModelicaCode> = {
    within_clause? <chunks:modelica_code+> => chunks,
};

pub modelica_code: ModelicaCode = {
    model =>            ModelicaCode::Model(<>),
    // TODO: class
    record =>           ModelicaCode::Record(<>),
    block =>            ModelicaCode::Block(<>),
    connector =>        ModelicaCode::Connector(<>),
    type_declaration => ModelicaCode::Type(<>),
    package =>          ModelicaCode::Package(<>),
    // TODO: function
};

pub package: ModelicaPackage = {
    "package" <n:identifier> <desc:string_literal?>
            extends_clause*
            <children:modelica_code*>
            "end" identifier ";" =>
        ModelicaPackage {
            name:n,
            description:desc,
            children:children,
            },
};

pub connector: ModelicaConnector = {
    "connector" <n:identifier> <desc:string_literal?>
            <cpc:component_clause*>
            "end" identifier ";" =>
        ModelicaConnector {
            name:n,
            description:desc,
            components: { collapse_components(&cpc) } },
};

pub record: ModelicaRecord = {
    "record" <n:identifier> <desc:string_literal?>
            <cpc:component_clause*>
            "end" identifier ";" =>
        ModelicaRecord {
            name:n,
            description:desc,
            components: { collapse_components(&cpc) } },
};

type_declaration: ModelicaType = {
    "type" <n:identifier> <desc:string_literal?>
            "=" <cpd:component_declaration> ";" =>
        ModelicaType {
            name:n,
            description:desc,
            component:cpd, },
};

pub block: ModelicaBlock = {
    "block" <n:identifier> <desc:string_literal?>
            extends_clause*
            <cpc:component_clause*>
            <public:("public" <component_clause*>)?>
            <protected:("protected" <component_clause*>)?>
            "equation"
            <cc:connect_clause*>
            <se:simple_equation*>
            "end" identifier ";" =>
        ModelicaBlock {
            name:n,
            description:desc,
            components: { collapse_components(&cpc) },
            public_components: { collapse_components(&public.unwrap_or(vec![])) },
            protected_components: { collapse_components(&protected.unwrap_or(vec![])) },
            connections:cc,
            equations:se },
};

pub model: ModelicaModel = {
    "partial"? "model" <n:identifier> <desc:string_literal?>
            extends_clause*
            <cpc:component_clause*>
            connector*
            "equation"
            <cc:connect_clause*>
            <se:simple_equation*>
            "end" identifier ";" =>
        ModelicaModel {
            name:n,
            description:desc,
            components: { collapse_components(&cpc) },
            connections:cc,
            equations:se,
            },
};

extends_clause: String = {
    "extends" <identifier> ";" => <>,
};

within_clause: String = {
    "within" <identifier> ";" => <>,
};

component_clause: ComponentClause = {
    <prefix:component_prefix?>
            <specifier:identifier>
            <declarations:component_declaration+> ";" =>
        ComponentClause {
            prefix:prefix,
            specifier:specifier,
            declarations:declarations },
};

component_declaration: ComponentDeclaration = {
    <name:identifier>
            <ad:array_dimensions?>
            <mods:class_mod?>
            <value:assignment_mod?>
            <desc:string_literal?>
            (",")? =>
        ComponentDeclaration {
            name:name,
            dimensions:ad,
            description:desc,
            value:value,
            mods: { mods.unwrap_or(HashMap::new()) },
            quantity:None },
};

//  component_assigns happen in:
//      component declarations
//      argument lists
//  class_modifications (parens) happen in the above plus:
//      annotations
//      extends
//      RHS of single-line class defs

assignment_mod: Expr = {
    "=" <expr> => <>,
};

class_mod: HashMap<String, Expr> = {
    "(" <calist:(<component_assign> ","?)+> ")" => {
            let mut out: HashMap<String, Expr> = HashMap::new();
            for ca in calist {
                out.insert(ca.0, ca.1);
            }
            out
        }
};

component_assign: (String, Expr) = {
    <i:identifier> "=" <e:expr> => (i, e),
};

annotation: () = {
    "annotation" class_mod? => (),
};

// TODO: this is very partial/cludgy
array_dimensions: Vec<i64> = {
    "[" <dimensions:(<integer> ","?)+> "]" => dimensions,
    "[" ":" "]" => vec![],
};

component_prefix: ComponentPrefix = {
    "flow" => ComponentPrefix::Flow,
    "stream" => ComponentPrefix::Stream,
    "input" => ComponentPrefix::Input,
    "output" => ComponentPrefix::Output,
    "discrete" => ComponentPrefix::Discrete,
    "parameter" => ComponentPrefix::Parameter,
    "constant" => ComponentPrefix::Constant,
};

simple_equation: SimpleEquation = {
    <lhs:expr> "="  <rhs:expr> ";" => SimpleEquation {lhs:lhs, rhs:rhs},
};

connect_clause: Connection = {
    "connect" "(" <a:identifier> "," <b:identifier> ")" ";" =>
        Connection { a: a.to_string(), b: b.to_string()},
};

// This weird expr/factor/term hierarchy is for binary operator precedence
expr: Expr = {
    <lhs:expr> "+" <rhs:factor> =>
        Expr::BinExpr(BinOperator::Add, Box::new(lhs), Box::new(rhs)),
    <lhs:expr> "-" <rhs:factor> =>
        Expr::BinExpr(BinOperator::Subtract, Box::new(lhs), Box::new(rhs)),
    factor,
};

factor: Expr = {
    <lhs:factor> "*" <rhs:term> =>
        Expr::BinExpr(BinOperator::Multiply, Box::new(lhs), Box::new(rhs)),
    <lhs:factor> "/" <rhs:term> =>
        Expr::BinExpr(BinOperator::Divide, Box::new(lhs), Box::new(rhs)),
    <lhs:factor> "^" <rhs:term> =>
        Expr::BinExpr(BinOperator::Divide, Box::new(lhs), Box::new(rhs)),
    "-" <t:term> =>
        Expr::BinExpr(BinOperator::Multiply, Box::new(Expr::Integer(-1)), Box::new(t)),
    term,
};

// TODO: elementwise operators (".+", "./", ".*", ".-")

term: Expr = {
    integer => Expr::Integer(<>),
    boolean => Expr::Boolean(<>),
    float => Expr::Float(<>),
    identifier => Expr::Ident(<>),
    string_literal => Expr::StringLiteral(<>),
    "der"   "(" <e:expr> ")" => Expr::Der(Box::new(e)),
    "abs"   "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Abs, Box::new(e)),
    "sqrt"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Sqrt, Box::new(e)),
    "sin"   "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Sin, Box::new(e)),
    "cos"   "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Cos, Box::new(e)),
    "tan"   "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Tan, Box::new(e)),
    "asin"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Asin, Box::new(e)),
    "acos"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Acos, Box::new(e)),
    "atan"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Atan, Box::new(e)),
    "sinh"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Sinh, Box::new(e)),
    "cosh"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Cosh, Box::new(e)),
    "tanh"  "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Tanh, Box::new(e)),
    "exp"   "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Exp, Box::new(e)),
    "log"   "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Log, Box::new(e)),
    "log10" "(" <e:expr> ")" => Expr::MathUnaryExpr(MathUnaryFunc::Log10, Box::new(e)),
    "(" <e:expr> ")" => e,
    // Obviously a hack here, only supporting up to 4 elements in an array
    "[" <e:expr> "]" => Expr::Array(vec![e]),
    "[" <e1:expr> ";" <e2:expr> "]" => Expr::Array(vec![e1, e2]),
    "[" <e1:expr> "," <e2:expr> "]" => Expr::Array(vec![e1, e2]),
    "[" <e1:expr> "," <e2:expr> "," <e3:expr> "]" => Expr::Array(vec![e1, e2, e3]),
    "[" <e1:expr> "," <e2:expr> "," <e3:expr> "," <e4:expr> "]" => Expr::Array(vec![e1, e2, e3, e4]),
};