use crate::gen::schema::*;
use crate::syntax::block::constructors::*;
use crate::syntax::block::{escape_string, Emittable, Item};
use crate::*;

use std::cell::Cell;
use std::rc::Rc;

use super::context::{FunctionContext, ModuleContext, ModuleContextMode};
use super::names;
use super::types::*;

#[derive(Debug)]
pub struct UnparserPlugin;

impl compiler::Plugin for UnparserPlugin {
    fn generate_definition(
        &self,
        module_ctxt: &mut ModuleContext,
        definition_name: &str,
        definition: &Definition,
    ) {
        if let ModuleContextMode::TargetGeneric = module_ctxt.mode {
            gen_definition_unparser(module_ctxt, definition_name, definition)
        }
    }
}

type ValueSource = Option<String>;

#[derive(Clone)]
struct FieldsSink {
    finish: Item,
    vec_expr: Item,
    body: Vec<Item>,
}

#[derive(Clone)]
enum ValueSink {
    Normal,
    Fields(Rc<Cell<Option<FieldsSink>>>),
}

impl std::fmt::Debug for ValueSink {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
        match self {
            ValueSink::Normal => write!(f, "ValueSink::Normal"),
            ValueSink::Fields(_) => write!(f, "ValueSink::Normal"),
        }
    }
}

#[derive(Debug)]
struct ValueContext {
    src: ValueSource,
    sink: ValueSink,
    is_struct: bool,
}

fn normal_none(is_struct: bool) -> ValueContext {
    ValueContext {
        src: None,
        sink: ValueSink::Normal,
        is_struct,
    }
}

fn normal_src(src: String, is_struct: bool) -> ValueContext {
    ValueContext {
        src: Some(src),
        sink: ValueSink::Normal,
        is_struct,
    }
}

pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
    let ty = definition_type(&m.module_path, Purpose::Codegen, n, d);

    m.define_function(n, |mut ctxt| {
        let mut body = vec![];

        match d {
            Definition::Or {
                pattern_0,
                pattern_1,
                pattern_n,
            } => {
                let mut ps = vec![&**pattern_0, &**pattern_1];
                ps.extend(pattern_n);
                body.push(item(seq![
                    "match self ",
                    codeblock(
                        ps.iter()
                            .map(
                                |NamedAlternative {
                                     variant_label: name,
                                     pattern: pat,
                                 }| ctxt.branch(|ctxt| {
                                    let ctorname = item(name![
                                        names::render_constructor(n),
                                        names::render_constructor(name)
                                    ]);
                                    let (patpat, vc) =
                                        destruct(ctxt, ctorname, false, &pattern_type(pat));
                                    item(seq![
                                        patpat,
                                        " => ",
                                        pattern_unparser(ctxt, pat, &vc),
                                        ","
                                    ])
                                })
                            )
                            .collect()
                    )
                ]));
            }
            Definition::And {
                pattern_0,
                pattern_1,
                pattern_n,
            } => {
                let mut ps = vec![&**pattern_0, &**pattern_1];
                ps.extend(pattern_n);
                let (patpat, vc) = destruct(
                    &mut ctxt,
                    item(names::render_constructor(n)),
                    true,
                    &record_type(&ps),
                );
                body.push(item(seq!["let ", patpat, " = self;"]));
                body.push(item(seq![
                    "preserves::value::merge(vec!",
                    brackets(
                        ps.iter()
                            .map(|p| named_pattern_unparser(&mut ctxt, p, &vc))
                            .collect()
                    ),
                    ").expect",
                    parens![escape_string(
                        &("merge of ".to_owned() + &ctxt.fully_qualified_error_context())
                    )]
                ]));
            }
            Definition::Pattern(p) => {
                let (patpat, vc) = destruct(
                    &mut ctxt,
                    item(names::render_constructor(n)),
                    true,
                    &pattern_type(p),
                );
                body.push(item(seq!["let ", patpat, " = self;"]));
                body.push(pattern_unparser(&mut ctxt, p, &vc));
            }
        }

        item(seq![
            "impl",
            ctxt.m.parse_unparse_generic_decls(&ty),
            " _support::Unparse",
            anglebrackets!["_L", ctxt.m.any_type()],
            " for ",
            names::render_constructor(n),
            ty.generic_arg(ctxt.m),
            " ",
            codeblock![seq![
                "fn unparse(&self, _ctxt: _L) -> ",
                ctxt.m.any_type(),
                " ",
                codeblock(body)
            ]]
        ])
    });
}

fn destruct(
    ctxt: &mut FunctionContext,
    ctorname: Item,
    is_struct: bool,
    ty: &TSimple,
) -> (impl Emittable, ValueContext) {
    match ty {
        TSimple::Field(TField::Unit) => (seq![ctorname], normal_none(is_struct)),
        TSimple::Field(_) => {
            let src = ctxt.gentempname();
            (
                seq![ctorname, parens![src.to_owned()]],
                normal_src(src, is_struct),
            )
        }
        TSimple::Record(TRecord(fs)) => {
            for (fname, fty) in fs {
                let fsrc = ctxt.gentempname();
                ctxt.capture(names::render_fieldname(fname), fty.clone(), fsrc);
            }
            (
                seq![
                    ctorname,
                    " ",
                    braces(
                        ctxt.captures
                            .iter()
                            .map(|c| item(seq![c.field_name.clone(), ": ", c.source_expr.clone()]))
                            .collect()
                    )
                ],
                normal_none(is_struct),
            )
        }
    }
}

fn simple_pattern_unparser(
    ctxt: &mut FunctionContext,
    p: &SimplePattern,
    vc: &ValueContext,
) -> Item {
    let src = &vc.src;
    match p {
        SimplePattern::Any => item(seq![src.as_ref().unwrap().to_owned(), ".clone()"]),
        SimplePattern::Atom { atom_kind: k } => match &**k {
            AtomKind::Symbol => item(seq![
                "preserves::value::Value::symbol(",
                src.as_ref().unwrap().to_owned(),
                ").wrap()"
            ]),
            AtomKind::ByteString => item(seq![
                "preserves::value::Value::ByteString(",
                src.as_ref().unwrap().to_owned(),
                ".clone()).wrap()"
            ]),
            _ => item(seq![
                "preserves::value::Value::from(",
                src.as_ref().unwrap().to_owned(),
                ").wrap()"
            ]),
        },
        SimplePattern::Embedded { .. } => item(seq![
            "preserves::value::Value::Embedded(",
            src.as_ref().unwrap().to_owned(),
            ".clone()).wrap()"
        ]),
        SimplePattern::Lit { value } => {
            item(seq![parens![ctxt.m.define_literal(value)], ".clone()"])
        }
        SimplePattern::Seqof { pattern } => {
            let mut fields_sink = sequenceify(ctxt, vc);
            let tmp = ctxt.gentempname();
            fields_sink.body.push(item(seq![
                "for ",
                tmp.to_owned(),
                " in ",
                src.as_ref().unwrap().to_owned(),
                " ",
                codeblock![seq![
                    fields_sink.vec_expr.clone(),
                    ".push(",
                    simple_pattern_unparser(ctxt, pattern, &normal_src(tmp, true)),
                    ");"
                ]]
            ]));
            finish(fields_sink)
        }
        SimplePattern::Setof { pattern } => {
            let tmp = ctxt.gentempname();
            item(seq![
                "preserves::value::Value::Set(",
                src.as_ref().unwrap().to_owned(),
                ".iter().map(|",
                tmp.to_owned(),
                "| ",
                simple_pattern_unparser(ctxt, pattern, &normal_src(tmp, true)),
                ").collect()).wrap()"
            ])
        }
        SimplePattern::Dictof { key, value } => {
            let tmp_key = ctxt.gentempname();
            let tmp_value = ctxt.gentempname();
            item(seq![
                "preserves::value::Value::Dictionary(",
                src.as_ref().unwrap().to_owned(),
                ".iter().map(|(",
                tmp_key.to_owned(),
                ", ",
                tmp_value.to_owned(),
                ")| ",
                parens![
                    simple_pattern_unparser(ctxt, key, &normal_src(tmp_key, true)),
                    simple_pattern_unparser(ctxt, value, &normal_src(tmp_value, true))
                ],
                ").collect()).wrap()"
            ])
        }
        SimplePattern::Ref(_r) => item(seq![
            src.as_ref().unwrap().to_owned(),
            if vc.is_struct { "" } else { ".as_ref()" },
            ".unparse(_ctxt)"
        ]),
    }
}

fn named_pattern_unparser(ctxt: &mut FunctionContext, p: &NamedPattern, vc: &ValueContext) -> Item {
    match p {
        NamedPattern::Anonymous(p) => pattern_unparser(ctxt, p, vc),
        NamedPattern::Named(b) => {
            let Binding { name, pattern } = &**b;
            let src = ctxt
                .lookup_capture(&names::render_fieldname(name))
                .source_expr
                .to_owned();
            simple_pattern_unparser(
                ctxt,
                pattern,
                &ValueContext {
                    src: Some(src),
                    sink: vc.sink.clone(),
                    is_struct: vc.is_struct,
                },
            )
        }
    }
}

fn pattern_unparser(ctxt: &mut FunctionContext, p: &Pattern, vc: &ValueContext) -> Item {
    match p {
        Pattern::SimplePattern(s) => simple_pattern_unparser(ctxt, s, vc),
        Pattern::CompoundPattern(c) => match &**c {
            CompoundPattern::Rec { label, fields } => {
                let rtmp = ctxt.gentempname();
                let mut body = Vec::new();
                let init_expr = item(seq![
                    "preserves::value::Record(vec![",
                    named_pattern_unparser(ctxt, label, &normal_none(vc.is_struct)),
                    "])"
                ]);
                ctxt.declare_compound(&mut body, &rtmp, init_expr);
                named_pattern_unparser(
                    ctxt,
                    fields,
                    &ValueContext {
                        src: None,
                        sink: ValueSink::Fields(Rc::new(Cell::new(Some(FieldsSink {
                            finish: item(seq![rtmp.clone(), ".finish().wrap()"]),
                            vec_expr: item(seq![rtmp.clone(), ".fields_vec_mut()"]),
                            body,
                        })))),
                        is_struct: vc.is_struct,
                    },
                )
            }
            CompoundPattern::Tuple { patterns } => {
                let mut fields_sink = sequenceify(ctxt, vc);
                fixed_sequence_parser(ctxt, patterns, &mut fields_sink, vc.is_struct);
                finish(fields_sink)
            }
            CompoundPattern::TuplePrefix { fixed, variable } => {
                let mut fields_sink = sequenceify(ctxt, vc);
                fixed_sequence_parser(ctxt, fixed, &mut fields_sink, vc.is_struct);
                named_pattern_unparser(
                    ctxt,
                    &promote(variable),
                    &ValueContext {
                        src: vc.src.clone(),
                        sink: ValueSink::Fields(Rc::new(Cell::new(Some(fields_sink)))),
                        is_struct: true,
                    },
                )
            }
            CompoundPattern::Dict { entries } => {
                let dtmp = ctxt.gentempname();
                let mut body = Vec::new();
                ctxt.declare_compound(&mut body, &dtmp, item("preserves::value::Map::new()"));
                for (key_lit, value_pat) in entries.0.iter() {
                    body.push(item(seq![
                        dtmp.clone(),
                        ".insert",
                        parens![
                            seq![parens![ctxt.m.define_literal(key_lit)], ".clone()"],
                            named_pattern_unparser(
                                ctxt,
                                &promote(value_pat),
                                &normal_none(vc.is_struct)
                            )
                        ],
                        ";"
                    ]));
                }
                body.push(item(seq![
                    "preserves::value::Value::Dictionary(",
                    dtmp,
                    ").wrap()"
                ]));
                item(codeblock(body))
            }
        },
    }
}

fn sequenceify<'a>(ctxt: &mut FunctionContext, vc: &'a ValueContext) -> FieldsSink {
    match vc {
        ValueContext {
            sink: ValueSink::Fields(fields_sink),
            ..
        } => (**fields_sink).take().unwrap(),
        _ => {
            let rtmp = ctxt.gentempname();
            let mut body = Vec::new();
            ctxt.declare_compound(&mut body, &rtmp, item("std::vec::Vec::new()"));
            FieldsSink {
                finish: item(seq![
                    "preserves::value::Value::Sequence",
                    parens![rtmp.clone()],
                    ".wrap()"
                ]),
                vec_expr: item(rtmp),
                body,
            }
        }
    }
}

fn finish(mut fields_sink: FieldsSink) -> Item {
    fields_sink.body.push(fields_sink.finish);
    item(codeblock(fields_sink.body))
}

fn fixed_sequence_parser(
    ctxt: &mut FunctionContext,
    patterns: &Vec<NamedPattern>,
    fields_sink: &mut FieldsSink,
    is_struct: bool,
) {
    for p in patterns {
        fields_sink.body.push(item(seq![
            fields_sink.vec_expr.clone(),
            ".push",
            parens![named_pattern_unparser(ctxt, p, &normal_none(is_struct))],
            ";"
        ]));
    }
}