use std::rc::Rc;
use std::str::FromStr;
use lalrpop_util::ParseError;
use crate::rsprocess::structure::{RSset,
				  RSprocess,
				  RSenvironment,
				  RSassert,
				  RSassertOp,
				  RSBHML,
				  RSsystem,
				  RSreaction};
use crate::rsprocess::translator::{Translator, IdType};
use crate::rsprocess::presets::Instructions;
use crate::rsprocess::presets;
use crate::rsprocess::graph;

grammar(translator: &mut Translator);

// -----------------------------------------------------------------------------
//                                  Helpers
// -----------------------------------------------------------------------------

// order
match {
    ".", ",", ";",
    "nill",
    "{", "}",
    "[", "]",
    "(", ")",
    "<", ">",
    "r:", "i:", "p:",
    "-", "^",
    "true", "false",
    "inW", "inR", "inI", "inP",
    "Environment", "Initial Entities", "Context", "Reactions",
    "Weights", "Sets",
    "Print", "Save",
    "Dot", "GraphML", "Serialize",
    "Stats", "Target", "Run", "Loop", "Frequency", "LimitFrequency",
    "FastFrequency", "Digraph", "Bisimilarity",
    "Deserialize",
    "Hide", "Entities", "MaskEntities", "MaskContext",
    "Products", "MaskProducts", "Union", "MaskUnion",
    "Difference", "MaskDifference",
    "EntitiesDeleted", "MaskEntitiesDeleted",
    "EntitiesAdded", "MaskEntitiesAdded"
} else {
    r"[0-9]+" => NUMBER
} else {
    r"([[:alpha:]])([[:word:]])*" => WORD
    // r"(\p{L}|\p{Emoji})(\p{L}|\p{Emoji}|\p{Dash}|\p{N})*" => WORD,
} else {
    r#""[^"]+""# => PATH, // " <- ignore comment, its for the linter in emacs
} else {
    _
}


// matches words (letter followed by numbers, letters or _)
Literal: String = {
    WORD => <>.to_string()
};

// all numbers are i64
Num: i64 = {
    NUMBER =>? i64::from_str(<>)
		  .map_err(|_| ParseError::User { error: "Number is too big" })
};

Path: String = {
    PATH => <>.trim_end_matches("\"").trim_start_matches("\"").to_string()
};

// macro for matching sequence of patterns with C as separator
Separated<T, C>: Vec<T> = {
    <mut v:(<T> C)+> <e:T?> => match e {
	None => v,
	Some(e) => {
	    v.push(e);
	    v
	}
    }
};

Separated_Or<T, C>: Vec<T> = {
    <v: T> => vec![v],
    <v: Separated<T, C>> => v
}

// -----------------------------------------------------------------------------
//                                 SetParser
// -----------------------------------------------------------------------------
pub Set: RSset = {
    <s: Set_of_entities> => s
};

Set_of_entities: RSset = {
    "{" "}" => RSset::from(vec![]),
    "{" <t: Separated_Or<Literal, ",">> "}" =>
	RSset::from(t.into_iter().map(|t| translator.encode(t))
						    .collect::<Vec<_>>())
};


// -----------------------------------------------------------------------------
//                               ReactionParser
// -----------------------------------------------------------------------------

pub Reactions: Vec<RSreaction> = {
    "(" ")" => vec![],
    "(" <s: Separated_Or<Reaction, ";">> ")" => s
}

Reaction: RSreaction = {
    "[" <r: Set> "," <i: Set> "," <p: Set> "]" => RSreaction::from(r, i, p),
    "[" "r:" <r: Set> "," "i:" <i: Set> "," "p:" <p: Set> "]" =>
	RSreaction::from(r, i, p),
}

// -----------------------------------------------------------------------------
//                               ContextParser
// -----------------------------------------------------------------------------
pub Context: RSprocess = {
    "[" "]" => RSprocess::NondeterministicChoice{ children: vec![] },
    "[" <t: Separated_Or<Boxed_CTX_process, ",">> "]" =>
	RSprocess::NondeterministicChoice{ children: t }
};

Boxed_CTX_process: Rc<RSprocess> = {
    <t: CTX_process> => Rc::new(t)
}

CTX_process: RSprocess = {
    "nill" => RSprocess::Nill,
    <c: Set_of_entities> "." <k: CTX_process> =>
	RSprocess::EntitySet{ entities: c, next_process: Rc::new(k) },
    "(" <k: CTX_process>  ")" => k,
    "(" <k: Separated<CTX_process, "+">> ")" =>
	RSprocess::Summation{
		children: k.into_iter().map(Rc::new).collect::<Vec<_>>()
	},
    "<" <n: Num> <k1: CTX_process> ">" "." <k: CTX_process> =>
	RSprocess::WaitEntity{ repeat: n,
			       repeated_process: Rc::new(k1),
			       next_process: Rc::new(k) },
    <identifier: Literal> =>
	RSprocess::RecursiveIdentifier{
		identifier: translator.encode(identifier)
	}
};

// -----------------------------------------------------------------------------
//                             EnvironmentParser
// -----------------------------------------------------------------------------
pub Environment: Box<RSenvironment> = {
    "[" "]" => Box::new(RSenvironment::new()),
    "[" <t: Separated_Or<Env_term, ",">> "]" => Box::new(RSenvironment::from(t))
};

Env_term: (IdType, RSprocess) = {
    <identifier: Literal> "=" <k: CTX_process> =>
	(translator.encode(identifier), k)
};

// -----------------------------------------------------------------------------
//                                AssertParser
// -----------------------------------------------------------------------------
pub Assert: Box<RSassert> = {
    <f: Formula_Assert> => Box::new(f)
};

Formula_Assert: RSassert = {
    "-" <f: Formula_Assert> => RSassert::Not(Box::new(f)),
    "(" <f1: Formula_Assert> "^" <f2: Formula_Assert> ")" =>
	RSassert::Xor(Box::new(f1), Box::new(f2)),
    "(" <f: Separated<Formula_Assert, "\\/">> ")" => RSassert::Or(f),
    "(" <f: Separated<Formula_Assert, "/\\">> ")" => RSassert::And(f),
    <c: Set_of_entities> "inW" => RSassert::Sub(c, RSassertOp::InW),
    <c: Set_of_entities> "inR" => RSassert::Sub(c, RSassertOp::InR),
    <c: Set_of_entities> "inI" => RSassert::Sub(c, RSassertOp::InI),
    <c: Set_of_entities> "inP" => RSassert::Sub(c, RSassertOp::InP),
    "?" "inW" => RSassert::NonEmpty(RSassertOp::InW),
    "?" "inR" => RSassert::NonEmpty(RSassertOp::InR),
    "?" "inI" => RSassert::NonEmpty(RSassertOp::InI),
    "?" "inP" => RSassert::NonEmpty(RSassertOp::InP),
};

// -----------------------------------------------------------------------------
//                                 BHMLParser
// -----------------------------------------------------------------------------
pub BHML: Box<RSBHML> = {
    <g: Formula_BHML> => Box::new(g)
};

Formula_BHML: RSBHML = {
    "true" => RSBHML::True,
    "false" => RSBHML::False,
    "(" <g: Separated<Formula_BHML, "\\/">> ")" => RSBHML::Or(g),
    "(" <g: Separated<Formula_BHML, "/\\">> ")" => RSBHML::And(g),
    "<" <f: Formula_Assert> ">" <g: Formula_BHML> =>
	RSBHML::Diamond(Box::new(f), Box::new(g)),
    "[" <f: Formula_Assert> "]" <g: Formula_BHML> =>
	RSBHML::Box(Box::new(f), Box::new(g)),
};


// ----------------------------------------------------------------------------
//                                File Parsing
// ----------------------------------------------------------------------------

// system
// a system is an environment, a set of entities as initial state, a context and
// a set of reaction rules.

pub System: RSsystem = {
    "Environment" ":" <delta: Environment>
    "Initial Entities" ":" <available_entities: Set>
    "Context" ":" <context_process: Context>
    "Reactions" ":" <reaction_rules: Reactions>
	=> RSsystem::from(delta.into(),
			  available_entities,
			  context_process,
			  Rc::new(reaction_rules))
}

// experiment
// an experiment is composed by a sequence of weights and a sequence of sets of
// entities of equal length.

pub Experiment: (Vec<u32>, Vec<RSset>) = {
    "Weights" ":" <w: Separated_Or<Num, ",">>
    "Sets" ":" <s: Separated_Or<Set_of_entities, ",">>
	=> (w.into_iter().map(|x| x as u32).collect::<Vec<_>>(), s),
}


// ~~~~~~~~~~~~~~~~~~~
// Instruction Parsing
// ~~~~~~~~~~~~~~~~~~~

/// Decides whetherer to print to stdout or to save to file
Helper_SO: presets::SaveOptions = {
    "Print" =>
	presets::SaveOptions {print: true, save: None},
    "Save" "(" <p: Path> ")" =>
	presets::SaveOptions {print: false, save: Some(vec![p])}
}

/// we could need to save to multiple files
SaveOptions: presets::SaveOptions = {
    <p: Separated_Or<Helper_SO, ";">> => {
	p.into_iter()
	 .reduce(|mut acc, mut e| {acc.combine(&mut e); acc})
	 .unwrap_or_default()
    }
}

/// Match for strings between nodes formatters
LiteralSeparatorNode: presets::NodeDisplay = {
    PATH =>
	presets::NodeDisplay::Separator(
	    <>.trim_end_matches("\"").trim_start_matches("\"").to_string()
	)
};

/// Match for strings between edge formatters
LiteralSeparatorEdge: presets::EdgeDisplay = {
    PATH =>
	presets::EdgeDisplay::Separator(
	    <>.trim_end_matches("\"").trim_start_matches("\"").to_string()
	)
};

NodeDisplay: presets::NodeDisplay = {
    "Hide" =>
	presets::NodeDisplay::Display(graph::GraphMapNodes::Hide),
    "Entities" =>
	presets::NodeDisplay::Display(graph::GraphMapNodes::Entities),
    "MaskEntities" <mask: Set> =>
	presets::NodeDisplay::Display(graph::GraphMapNodes::MaskEntities{mask}),
    "Context" =>
	presets::NodeDisplay::Display(graph::GraphMapNodes::Context),
    "UncommonEntities" =>
	presets::NodeDisplay::UncommonEntities,
    "MaskUncommonentities" <mask: Set> =>
	presets::NodeDisplay::MaskUncommonEntities(mask),
    "ExcludeEntities" <mask: Set> =>
      presets::NodeDisplay::Display(graph::GraphMapNodes::ExcludeEntities{mask})
}

/// Node display formatters separated by arbitrary strings in quotes
SeparatorNode: Vec<presets::NodeDisplay> = {
    <v: NodeDisplay> => vec![v],
    <v:(<NodeDisplay> <LiteralSeparatorNode>)+> <e: NodeDisplay?> =>
	match e {
	    None => v.iter().fold(vec![],
				  |mut acc, (a, b)| {
				      acc.push(a.clone());
				      acc.push(b.clone());
				      acc.clone()
				  }),
	    Some(e) => {
		let mut v = v.iter().fold(vec![],
					  |mut acc, (a, b)| {
					      acc.push(a.clone());
					      acc.push(b.clone());
					      acc.clone()
					  });
		v.push(e);
		v
	    }
	}
}

EdgeDisplay: presets::EdgeDisplay = {
    "Hide" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::Hide
	),
    "Products" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::Products
	),
    "MaskProducts" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskEntities{ mask }
	),
    "Entities" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::Entities
	),
    "MaskEntities" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskEntities{ mask }
	),
    "Context" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::Context
	),
    "MaskContext" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskContext{ mask }
	),
    "Union" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::Union
	),
    "MaskUnion" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskUnion{ mask }
	),
    "Difference" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::Difference
	),
    "MaskDifference" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskDifference{ mask }
	),
    "EntitiesDeleted" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::EntitiesDeleted
	),
    "MaskEntitiesDeleted" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskEntitiesDeleted{ mask }
	),
    "EntitiesAdded" =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::EntitiesAdded
	),
    "MaskEntitiesAdded" <mask: Set> =>
	presets::EdgeDisplay::Display(
	    graph::GraphMapEdges::MaskEntitiesAdded{ mask }
	),
}

/// Edge display formatters separated by arbitrary strings in quotes
SeparatorEdge: Vec<presets::EdgeDisplay> = {
    <v: EdgeDisplay> => vec![v],
    <v:(<EdgeDisplay> <LiteralSeparatorEdge>)+> <e: EdgeDisplay?> =>
	match e {
	    None => v.iter().fold(vec![],
				  |mut acc, (a, b)| {
				      acc.push(a.clone());
				      acc.push(b.clone());
				      acc.clone()
				  }),
	    Some(e) => {
		let mut v = v.iter().fold(vec![],
					  |mut acc, (a, b)| {
					      acc.push(a.clone());
					      acc.push(b.clone());
					      acc.clone()
					  });
		v.push(e);
		v
	    }
	}
}

Operation: graph::OperationType = {
    "==" => graph::OperationType::Equals,
    "="  => graph::OperationType::Equals,
    "<"  => graph::OperationType::Subset,
    "⊂"  => graph::OperationType::Subset,
    "<=" => graph::OperationType::SubsetEqual,
    "⊆"  => graph::OperationType::SubsetEqual,
    ">"  => graph::OperationType::Superset,
    "⊃"  => graph::OperationType::Superset,
    ">=" => graph::OperationType::SupersetEqual,
    "⊇"  => graph::OperationType::SupersetEqual
}

NodeColorConditional: (graph::NodeColorConditional, String) = {
    "Entities" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::NodeColorConditional::EntitiesConditional(op, set),
	    color.to_string()),
    "Context.Nill" "?" <color: PATH> =>
	(graph::NodeColorConditional::ContextConditional(
	    graph::ContextColorConditional::Nill),
	    color.to_string()),
    "Context.RecursiveIdentifier" "(" <x: Literal> ")" "?" <color: PATH> =>
	(graph::NodeColorConditional::ContextConditional(
	    graph::ContextColorConditional::RecursiveIdentifier(
		translator.encode(x)
	    )),
	    color.to_string()),
    "Context.EntitySet" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::NodeColorConditional::ContextConditional(
	    graph::ContextColorConditional::EntitySet(op, set)),
	    color.to_string()),
    "Context.NonDeterministicChoice" "?" <color: PATH> =>
	(graph::NodeColorConditional::ContextConditional(
	    graph::ContextColorConditional::NonDeterministicChoice),
	    color.to_string()),
    "Context.Summation" "?" <color: PATH> =>
	(graph::NodeColorConditional::ContextConditional(
	    graph::ContextColorConditional::Summation),
	    color.to_string()),
    "Context.WaitEntity" "?" <color: PATH> =>
	(graph::NodeColorConditional::ContextConditional(
	    graph::ContextColorConditional::WaitEntity),
	    color.to_string()),
}


/// Node color formatter
ColorNode: graph::NodeColor = {
    <conditionals: Separated_Or<NodeColorConditional, "||">>
    "!" <base_color: PATH> =>
	graph::NodeColor { conditionals,
			   base_color: base_color.to_string() },

    "!" <base_color: PATH> =>
	graph::NodeColor { conditionals: vec![],
			   base_color: base_color.to_string() },
}

EdgeColorConditional: (graph::EdgeColorConditional, String) = {
    "Entities" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::Entities(op, set),
	    color.to_string()),
    "Context" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::Context(op, set),
	    color.to_string()),
    "T" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::T(op, set),
	    color.to_string()),
    "Reactants" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::Reactants(op, set),
	    color.to_string()),
    "AbsentReactants" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::ReactantsAbsent(op, set),
	    color.to_string()),
    "Inhibitors" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::Inhibitors(op, set),
	    color.to_string()),
    "PresentInhibitors" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::InhibitorsPresent(op, set),
	    color.to_string()),
    "Products" <op: Operation> <set: Set> "?" <color: PATH> =>
	(graph::EdgeColorConditional::Products(op, set),
	    color.to_string()),
}

ColorEdge: graph::EdgeColor = {
    <conditionals: Separated_Or<EdgeColorConditional, "||">>
    "!" <base_color: PATH> =>
	graph::EdgeColor { conditionals,
			   base_color: base_color.to_string() },

    "!" <base_color: PATH> =>
	graph::EdgeColor { conditionals: vec![],
			   base_color: base_color.to_string() },
}


GraphSaveOptions: presets::GraphSaveOptions = {
    "Dot" "|"? <s_node: SeparatorNode> "|" <s_edge: SeparatorEdge> "|"
	  <c_node: ColorNode> "|" <c_edge: ColorEdge> ">"
	<so: SaveOptions> =>
	presets::GraphSaveOptions::Dot { node_display: s_node,
					 edge_display: s_edge,
					 node_color:   c_node,
					 edge_color:   c_edge,
					 so },
    "GraphML" "|"? <s_node: SeparatorNode> "|" <s_edge: SeparatorEdge> ">"
	<so: SaveOptions> =>
	presets::GraphSaveOptions::GraphML { node_display: s_node,
					     edge_display: s_edge,
					     so },
    "Serialize" "(" <path: Path> ")" =>
	presets::GraphSaveOptions::Serialize { path },
}


Instruction: presets::Instruction = {
    "Stats" ">" <so: SaveOptions> =>
	presets::Instruction::Stats { so },
    "Target" ">" <so: SaveOptions> =>
	presets::Instruction::Target { so },
    "Run" ">" <so: SaveOptions> =>
	presets::Instruction::Run { so },
    "Loop" "(" <symbol: Literal> ")" ">" <so: SaveOptions> =>
	presets::Instruction::Loop { symbol,  so },
    "Frequency" ">" <so: SaveOptions> =>
	presets::Instruction::Frequency { so },
    "LimitFrequency" "(" <p: Path> ")" ">" <so: SaveOptions> =>
	presets::Instruction::LimitFrequency { experiment: p, so },
    "FastFrequency" "(" <p: Path> ")" ">" <so: SaveOptions> =>
	presets::Instruction::FastFrequency { experiment: p, so },
    "Digraph" ">" <gso: Separated_Or<GraphSaveOptions, "|">> =>
	presets::Instruction::Digraph { gso },
    "Bisimilarity" "(" <p: Path> ")" ">" <so: SaveOptions> =>
	presets::Instruction::Bisimilarity { system_b: p, so },
}

pub Run: presets::Instructions = {
    <sys: System> <instr: Separated_Or<Instruction, ",">> =>
	Instructions { system: presets::System::RSsystem { sys },
		       instructions: instr },

    <sys: System> =>
	Instructions { system: presets::System::RSsystem { sys },
		       instructions: vec![] },

    "Deserialize" "(" <path: Path> ")"
    <instr: Separated_Or<Instruction, ",">> =>
	Instructions { system: presets::System::Deserialize { path },
		       instructions: instr },
}