import Mathlib.Data.Nat.Size
import Mathlib.Data.List.Range
import Mathlib.Algebra.BigOperators.Group.List.Basic

namespace OAI

namespace NCHitting.BitModel

def width (n : ℕ) : ℕ := n.size + 1

def addCost (a b : ℕ) : ℕ := 4 * (width a + width b)
def mulCost (a b : ℕ) : ℕ := 8 * width a * width b
def compareCost (a b : ℕ) : ℕ := 2 * (width a + width b)

def listBits (xs : List ℕ) : ℕ := (xs.map width).sum

structure NatResult where
  value : ℕ
  cost : ℕ
  deriving DecidableEq, Repr

def powerRun (base : ℕ) : ℕ → NatResult
  | 0 => ⟨1, width 1⟩
  | k + 1 =>
      let previous := powerRun base k
      ⟨previous.value * base,
        previous.cost + mulCost previous.value base + addCost k 1 + 1⟩

@[simp] theorem powerRun_value (base k : ℕ) : (powerRun base k).value = base ^ k := by
  induction k with
  | zero => rfl
  | succ k ih => simp [powerRun, ih, pow_succ]

inductive Expr where
  | literal : ℕ → Expr
  | read : ℕ → Expr
  | add : Expr → Expr → Expr
  | sub : Expr → Expr → Expr
  | mul : Expr → Expr → Expr
  | power : Expr → Expr → Expr
  | less : Expr → Expr → Expr
  | equal : Expr → Expr → Expr
  | odd : Expr → Expr
  deriving DecidableEq, Repr

def Expr.run (environment : List ℕ) : Expr → NatResult
  | .literal n => ⟨n, width n + 1⟩
  | .read index =>
      ⟨environment[index]?.getD 0,
        width index + listBits (environment.take (index + 1)) + 1⟩
  | .add a b =>
      let x := a.run environment
      let y := b.run environment
      ⟨x.value + y.value, x.cost + y.cost + addCost x.value y.value + 1⟩
  | .sub a b =>
      let x := a.run environment
      let y := b.run environment
      ⟨x.value - y.value, x.cost + y.cost + addCost x.value y.value + 1⟩
  | .mul a b =>
      let x := a.run environment
      let y := b.run environment
      ⟨x.value * y.value, x.cost + y.cost + mulCost x.value y.value + 1⟩
  | .power a b =>
      let x := a.run environment
      let y := b.run environment
      let z := powerRun x.value y.value
      ⟨z.value, x.cost + y.cost + z.cost + 1⟩
  | .less a b =>
      let x := a.run environment
      let y := b.run environment
      ⟨if x.value < y.value then 1 else 0,
        x.cost + y.cost + compareCost x.value y.value + 1⟩
  | .equal a b =>
      let x := a.run environment
      let y := b.run environment
      ⟨if x.value = y.value then 1 else 0,
        x.cost + y.cost + compareCost x.value y.value + 1⟩
  | .odd a =>
      let x := a.run environment
      ⟨x.value % 2, x.cost + 2⟩

structure RationalCode where
  negative : Bool
  numerator : ℕ
  denominator : ℕ
  deriving DecidableEq, Repr

def RationalCode.bits (entry : RationalCode) : ℕ :=
  1 + width entry.numerator + width entry.denominator

def outputBits (entries : List RationalCode) : ℕ := (entries.map RationalCode.bits).sum

inductive Program where
  | skip : Program
  | emit : Expr → Expr → Expr → Program
  | sequence : Program → Program → Program
  | branch : Expr → Program → Program → Program
  | loop : Expr → Program → Program
  deriving DecidableEq, Repr

structure ProgramResult where
  output : List RationalCode
  cost : ℕ
  deriving DecidableEq, Repr

def Program.run (environment : List ℕ) : Program → ProgramResult
  | .skip => ⟨[], 1⟩
  | .emit sign numerator denominator =>
      let s := sign.run environment
      let a := numerator.run environment
      let b := denominator.run environment
      let entry : RationalCode := ⟨decide (s.value % 2 = 1), a.value, b.value⟩
      ⟨[entry], s.cost + a.cost + b.cost + entry.bits + 2⟩
  | .sequence p q =>
      let x := p.run environment
      let y := q.run environment
      ⟨x.output ++ y.output, x.cost + y.cost + outputBits x.output + 1⟩
  | .branch test yes no =>
      let t := test.run environment
      let result := if t.value = 0 then no.run environment else yes.run environment
      ⟨result.output, t.cost + result.cost + 1⟩
  | .loop bound body =>
      let b := bound.run environment
      let iterations := (List.range b.value).map fun index =>
        let result := body.run (index :: environment)
        (result, width index + addCost index 1 + 1)
      ⟨iterations.flatMap (fun result => result.1.output),
        b.cost + 1 + (iterations.map fun result =>
          result.1.cost + result.2 + outputBits result.1.output).sum⟩

def execute (program : Program) (inputs : List ℕ) : ProgramResult :=
  let result := program.run inputs
  ⟨result.output, listBits inputs + result.cost⟩

end NCHitting.BitModel

end OAI