import OAI.Combinatorics.ContingencyTables.Rooted.ForestEdgeChoiceProgram
import OAI.Combinatorics.ContingencyTables.Transport.DirectedBFSCode

namespace OAI

/-! # Canonical adjacency-list insertion of a forest edge

Every row is rebuilt from the stored vertex range. This keeps the graph
encoding canonical and bounds all intermediate lists by the vertex count.
-/

namespace ContingencyTables.ForestJoinProgram

open MatchingFPRAS.TreeTyped Polynomial FiniteGraphRootProgram SimpleGraph

abbrev Input := GraphCode×(ℕ×ℕ)
abbrev RowInput := Input×ℕ
abbrev TestInput := RowInput×ℕ

def keep (z : TestInput) : Bool :=
  decide (z.2∈z.1.1.1.getD z.1.2 []) ||
    ((decide (z.1.2=z.1.1.2.1) && decide (z.2=z.1.1.2.2)) ||
     (decide (z.1.2=z.1.1.2.2) && decide (z.2=z.1.1.2.1)))

def keepRealizer : Realizer keep := by
  let row : Realizer (fun z : TestInput=>z.1.2) := composition first second
  let u : Realizer (fun z : TestInput=>z.1.1.2.1) :=
    composition (composition (composition first first) second) first
  let v : Realizer (fun z : TestInput=>z.1.1.2.2) :=
    composition (composition (composition first first) second) second
  let old : Realizer (fun z : TestInput=>decide (z.2∈z.1.1.1.getD z.1.2 [])) :=
    composition (pair
      (composition (pair (composition (composition first first) first) row) (getDFast []))
      second) membership
  exact composition (pair old
    (composition (pair
      (composition (pair (composition (pair row u) natEqual)
        (composition (pair second v) natEqual)) boolAnd)
      (composition (pair (composition (pair row v) natEqual)
        (composition (pair second u) natEqual)) boolAnd)) boolOr)) boolOr

lemma polynomial_keep : PolynomialTime keepRealizer := by
  unfold keepRealizer
  have hr : PolynomialTime (composition (first (A:=RowInput) (B:=ℕ)) second) :=
    polynomial_composition polynomial_first polynomial_second
  have hu : PolynomialTime (composition (composition
      (composition (first (A:=RowInput) (B:=ℕ)) first) second) first) :=
    polynomial_composition (polynomial_composition
      (polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_first
  have hv : PolynomialTime (composition (composition
      (composition (first (A:=RowInput) (B:=ℕ)) first) second) second) :=
    polynomial_composition (polynomial_composition
      (polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_second
  apply polynomial_composition _ polynomial_boolOr
  apply polynomial_pair
  · exact polynomial_composition (polynomial_pair
      (polynomial_composition (polynomial_pair
        (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
          polynomial_first) hr) (polynomial_getDFast [])) polynomial_second) polynomial_membership
  · apply polynomial_composition _ polynomial_boolOr
    apply polynomial_pair
    · exact polynomial_composition (polynomial_pair
        (polynomial_composition (polynomial_pair hr hu) polynomial_natEqual)
        (polynomial_composition (polynomial_pair polynomial_second hv) polynomial_natEqual))
        polynomial_boolAnd
    · exact polynomial_composition (polynomial_pair
        (polynomial_composition (polynomial_pair hr hv) polynomial_natEqual)
        (polynomial_composition (polynomial_pair polynomial_second hu) polynomial_natEqual))
        polynomial_boolAnd

def vertices (z : RowInput) : List ℕ := indices z.1.1
def verticesRealizer : Realizer vertices :=
  composition (composition first first) indicesRealizer
lemma polynomial_vertices : PolynomialTime verticesRealizer :=
  polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_indices

def row (z : RowInput) : List ℕ := (vertices z).filter (fun a=>keep (z,a))
def rowRealizer : Realizer row :=
  composition (pair identity verticesRealizer) (filterWith keepRealizer)
lemma polynomial_row : PolynomialTime rowRealizer :=
  polynomial_composition (polynomial_pair polynomial_identity polynomial_vertices)
    (polynomial_filterWith polynomial_keep)

def join (z : Input) : GraphCode := (indices z.1).map (fun i=>row (z,i))
def joinRealizer : Realizer join :=
  composition (pair identity (composition first indicesRealizer)) (mapWith rowRealizer)
lemma polynomial_join : PolynomialTime joinRealizer :=
  polynomial_composition (polynomial_pair polynomial_identity
    (polynomial_composition polynomial_first polynomial_indices))
    (polynomial_mapWith polynomial_row)

lemma join_length (z : Input) : (join z).length=z.1.length := by
  simp only [join,List.length_map,indices,List.length_range]

lemma row_weight (z : RowInput) : weight (row z)≤weight (indices z.1.1) :=
  weight_sublist (List.filter_sublist (p:=fun a=>keep (z,a)) (l:=vertices z))

lemma join_weight (z : Input) :
    weight (join z)≤z.1.length*(4*z.1.length^2+2*z.1.length+2)+1 := by
  have hi := indices_weight z.1
  have hs : ∀ i∈indices z.1,weight (row (z,i))≤4*z.1.length^2+2*z.1.length+1 := by
    intro i _
    exact (row_weight (z,i)).trans (by nlinarith [hi])
  have h := weight_map_bound (as:=indices z.1) (f:=fun i=>row (z,i))
    (N:=4*z.1.length^2+2*z.1.length+1) hs
  simpa only [join,indices,List.length_range,Nat.add_assoc] using h

lemma keep_code {n : ℕ} (G : SimpleGraph (Fin n)) [DecidableRel G.Adj]
    (u v r a : Fin n) (hne : u≠v) :
    keep (((graphCode G,(u.val,v.val)),r.val),a.val)=true ↔
      (G⊔edge u v).Adj a r := by
  simp only [keep,graphCode_getD,Bool.or_eq_true,Bool.and_eq_true,decide_eq_true_eq]
  rw [adjacencyRow_mem]
  have he : (∃ w : Fin n,w.val=a.val ∧ G.Adj w r) ↔ G.Adj a r := by
    constructor
    · rintro ⟨w,hw,hwr⟩
      exact (Fin.ext hw) ▸ hwr
    · intro har
      exact ⟨a,rfl,har⟩
  rw [he]
  simp only [Fin.val_inj,SimpleGraph.sup_adj,SimpleGraph.edge_adj]
  constructor
  · rintro (h|(⟨hr,ha⟩|⟨hr,ha⟩))
    · exact Or.inl h
    · subst r; subst a; exact Or.inr ⟨Or.inr ⟨rfl,rfl⟩,Ne.symm hne⟩
    · subst r; subst a; exact Or.inr ⟨Or.inl ⟨rfl,rfl⟩,hne⟩
  · rintro (h|⟨(⟨ha,hr⟩|⟨ha,hr⟩),_⟩)
    · exact Or.inl h
    · exact Or.inr (Or.inr ⟨hr,ha⟩)
    · exact Or.inr (Or.inl ⟨hr,ha⟩)

lemma join_code {n : ℕ} (G : SimpleGraph (Fin n)) [DecidableRel G.Adj]
    (u v : Fin n) (hne : u≠v) :
    join (graphCode G,(u.val,v.val))=graphCode (G⊔edge u v) := by
  simp only [join,indices,graphCode_length,DirectedBFSCode.range_eq_map,←List.ofFn_eq_map,
    List.map_ofFn]
  change List.ofFn (fun r : Fin n=>row ((graphCode G,(u.val,v.val)),r.val)) =
    List.ofFn (adjacencyRow (G⊔edge u v))
  apply congrArg List.ofFn
  funext r
  simp only [row,vertices,indices,graphCode_length,
    DirectedBFSCode.range_eq_map,List.filter_map,adjacencyRow]
  apply congrArg (List.map Fin.val)
  apply List.filter_congr
  intro a _
  apply Bool.eq_iff_iff.mpr
  simpa only [decide_eq_true_eq,Function.comp_apply] using keep_code G u v r a hne

end ContingencyTables.ForestJoinProgram

end OAI