import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeListMore
import OAI.Combinatorics.MatchingCount.Tapes.Parse

namespace OAI

namespace MatchingFPRAS.LiteralInput
open TreeTyped TreeFunction Polynomial LiteralParse

abbrev PairState := (Bool×ℕ)×List (ℕ×ℕ)
def pairStep (x : ℕ×PairState) : PairState :=
  if x.2.1.1 then ((false,0),(x.1,x.2.1.2)::x.2.2) else ((true,x.1),x.2.2)
def pairStepRealizer : Realizer pairStep :=
  (choose second.fst.fst
    (pair (constant (false,0)) (composition (pair (pair first second.fst.snd) second.snd) listCons))
    (pair (pair (constant true) first) second.snd)).congr (by
      intro x;simp only [Function.comp_apply,pairStep])
lemma polynomial_pairStep : PolynomialTime pairStepRealizer := by
  unfold pairStepRealizer
  apply polynomial_congr
  dsimp only [Realizer.fst,Realizer.snd]
  tree_cost
lemma pairStep_weight (n : ℕ) (s : PairState) : weight (pairStep (n,s)) ≤ weight s+weight n+4 := by
  rcases s with ⟨⟨b,m⟩,es⟩
  cases b
  · change weight ((true,n),es) ≤ weight ((false,m),es)+weight n+4
    simp only [weight_prod]
    change 1+(1+3+weight n)+weight es ≤ 1+(1+1+weight m)+weight es+weight n+4
    omega
  · change weight ((false,0),(n,m)::es) ≤ weight ((true,m),es)+weight n+4
    simp only [weight_prod,weight_cons]
    change 1+(1+1+1)+(1+(1+weight n+weight m)+weight es) ≤
      1+(1+3+weight m)+weight es+weight n+4
    omega
lemma pairFold_weight (ns : List ℕ) (s : PairState) :
    weight (ns.foldl (fun s n=>pairStep (n,s)) s) ≤ weight s+5*weight ns := by
  induction ns generalizing s with
  | nil => simp
  | cons n ns ih =>
    have h := ih (pairStep (n,s))
    have h' := pairStep_weight n s
    simp only [List.foldl_cons,weight_cons]
    omega
lemma polynomial_pairFold : PolynomialTime (fold pairStepRealizer) := by
  apply polynomial_fold polynomial_pairStep (6*X)
  intro as s pre post he
  have h := pairFold_weight pre s
  have hw : weight pre ≤ weight as := by
    have ha := weight_append pre post
    have hp := weight_pos post
    rw [he]
    omega
  simp only [Polynomial.eval_mul,Polynomial.eval_ofNat,Polynomial.eval_X,weight_prod]
  omega

def pairs (ns : List ℕ) : List (ℕ×ℕ) := (ns.foldl (fun s n=>pairStep (n,s)) ((false,0),[])).2
def pairsRealizer : Realizer pairs :=
  (composition
    (composition (pair identity (constant (((false,0),[]) : PairState))) (fold pairStepRealizer)) second).congr (fun _=>rfl)
lemma polynomial_pairs : PolynomialTime pairsRealizer :=
  polynomial_congr _ (polynomial_composition (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant _))
    polynomial_pairFold) polynomial_second)
lemma pair_pair (i j : ℕ) (es : List (ℕ×ℕ)) :
    pairStep (i,pairStep (j,((false,0),es)))=((false,0),(i,j)::es) := rfl
lemma pairs_reverse (es : List (ℕ×ℕ)) (acc : List (ℕ×ℕ)) :
    ((es.flatMap (fun e=>[e.1,e.2])).reverse.foldl (fun s n=>pairStep (n,s)) ((false,0),acc))=
      ((false,0),es++acc) := by
  induction es generalizing acc with
  | nil => rfl
  | cons e es ih =>
    simp only [List.flatMap_cons,List.reverse_append,List.reverse_cons,List.reverse_nil,
      List.nil_append,List.singleton_append,List.foldl_append,ih,List.foldl_cons,List.foldl_nil,pair_pair]
    rfl

abbrev Parsed := ℕ×(List (ℕ×ℕ)×(TreeFraction.Fraction×TreeFraction.Fraction))
def ratTail (ns : List ℕ) : TreeFraction.Fraction×TreeFraction.Fraction :=
  ((ns.tail.tail.tail.headD 0,ns.tail.tail.headD 0),(ns.tail.headD 0,ns.headD 0))
def ratTailRealizer : Realizer ratTail :=
  pair (pair (composition (composition (composition tail tail) tail) (head 0))
    (composition (composition tail tail) (head 0)))
    (pair (composition tail (head 0)) (head 0))
lemma polynomial_ratTail : PolynomialTime ratTailRealizer := by
  unfold ratTailRealizer
  exact TreeTyped.polynomial_pair
    (TreeTyped.polynomial_pair
      (polynomial_composition (polynomial_composition (polynomial_composition polynomial_tail polynomial_tail)
        polynomial_tail) (polynomial_head _))
      (polynomial_composition (polynomial_composition polynomial_tail polynomial_tail) (polynomial_head _)))
    (TreeTyped.polynomial_pair (polynomial_composition polynomial_tail (polynomial_head _)) (polynomial_head _))

def fromNumbers (ns : List ℕ) : Parsed :=
  (ns.headD 0,(pairs ns.tail.tail.reverse.tail.tail.tail.tail,ratTail ns.tail.tail.reverse))
def reversedTailRealizer : Realizer (fun ns : List ℕ=>ns.tail.tail.reverse) :=
  composition (composition tail tail) reverse
def fromNumbersRealizer : Realizer fromNumbers :=
  (pair (head 0) (pair
    (composition (composition (composition (composition (composition reversedTailRealizer tail) tail) tail) tail) pairsRealizer)
    (composition reversedTailRealizer ratTailRealizer))).congr (fun _=>rfl)
lemma polynomial_reversedTail : PolynomialTime reversedTailRealizer :=
  polynomial_composition (polynomial_composition polynomial_tail polynomial_tail) polynomial_reverse
lemma polynomial_fromNumbers : PolynomialTime fromNumbersRealizer := by
  unfold fromNumbersRealizer
  apply polynomial_congr
  apply polynomial_pair (polynomial_head _)
  apply polynomial_pair
  · exact polynomial_composition (polynomial_composition (polynomial_composition
      (polynomial_composition (polynomial_composition polynomial_reversedTail polynomial_tail) polynomial_tail)
        polynomial_tail) polynomial_tail) polynomial_pairs
  · exact polynomial_composition polynomial_reversedTail polynomial_ratTail

def parseInput (as : List Symbol) : Parsed := fromNumbers (LiteralParse.parse as)
def parseInputRealizer : Realizer parseInput := composition LiteralParse.parseRealizer fromNumbersRealizer
lemma polynomial_parseInput : PolynomialTime parseInputRealizer :=
  polynomial_composition LiteralParse.polynomial_parse polynomial_fromNumbers

def edgeNumbers (G : GraphInput) : List (ℕ×ℕ) :=
  ((G.edges.map toLex.toEmbedding).sort (·≤·)).map (fun e=>((ofLex e).1.val,(ofLex e).2.val))
lemma edges_fold (es : List (ℕ×ℕ)) (ns : List ℕ) :
    (es.flatMap (fun e=>encodeNat e.1++encodeNat e.2)).foldr (fun a ns=>numStep (a,ns)) ns=
      es.flatMap (fun e=>[e.1,e.2])++ns := by
  induction es with
  | nil => rfl
  | cons e es ih =>
    simp only [List.flatMap_cons,List.foldr_append,ih,encodeNat_fold]
    rfl
lemma parse_source (G : GraphInput) (ε δ : ℚ) : LiteralParse.parse (encodeInput G ε δ)=
    G.n::G.edges.card::(edgeNumbers G).flatMap (fun e=>[e.1,e.2])++[ε.num.natAbs,ε.den,δ.num.natAbs,δ.den] := by
  unfold encodeInput LiteralParse.parse
  simp only [List.foldr_append,encodeNat_fold,encodeRat_fold]
  rw [show (((G.edges.map toLex.toEmbedding).sort (·≤·)).flatMap fun e=>encodeNat (ofLex e).1.val++encodeNat (ofLex e).2.val)=
    (edgeNumbers G).flatMap (fun e=>encodeNat e.1++encodeNat e.2) by simp only [edgeNumbers,List.flatMap_map]]
  rw [edges_fold]
  rfl
lemma parseInput_source (G : GraphInput) (ε δ : ℚ) :
    parseInput (encodeInput G ε δ)=(G.n,(edgeNumbers G,(TreeFraction.repr ε,TreeFraction.repr δ))) := by
  rw [parseInput,parse_source]
  unfold fromNumbers
  simp only [List.cons_append,List.headD_cons,List.tail_cons,
    List.reverse_append,List.reverse_cons,List.reverse_nil,List.nil_append]
  unfold ratTail
  simp only [List.headD_cons,List.tail_cons]
  unfold pairs
  rw [pairs_reverse]
  simp only [List.append_nil]
  rfl
end MatchingFPRAS.LiteralInput

end OAI