(* Title:  Interpret/lucas-interpreter.sml

   Author: Walther Neuper 2019

   (c) due to copyright terms

*)

signature COMPUTER_ALGEBRA_SYSTEM_COMMAND =

sig

  type T = CAS_Def.T

  val input : term -> (Ctree.ctree * Specification.T) option

  val is_from: TermC.as_string -> Formalise.T -> bool

(* ---- for tests only: shifted from below to remove the Warning "unused" at fun.def. --------- *)

  (*NONE*)

(*/-------------------------------------------------------- ! aktivate for Test_Isac BEGIN ---\* )

(* ---- for tests only: shifted from below to remove the Warning "unused" at fun.def. --------- *)

  val input_: References.T -> (term * term list) list ->

    Problem.id * I_Model.T * Method.id * I_Model.T * Pre_Conds.T * Proof.context

  val dtss2itm_: Model_Pattern.T -> term * term list ->

    int list * bool * string * I_Model.feedback (*I_Model.single'*)

  val flattup2: 'a * ('b * 'c * 'd * 'e) -> 'a * 'b * 'c * 'd * 'e

( *\--- ! aktivate for Test_Isac END ----------------------------------------------------------/*)

end

(**)

structure CAS_Cmd(**): COMPUTER_ALGEBRA_SYSTEM_COMMAND(**) =

struct

(**)

type T = CAS_Def.T;

fun dtss2itm_ ppc (d, ts) =

  let

    val (f, (d, id)) = the (find_first ((curry op= d) o 

  		(#1: (term * term) -> term) o

  		(#2: Model_Pattern.single -> (term * term))) ppc)

  in

    ([1], true, f, I_Model.Cor ((d, ts), (id, ts)))

  end

fun flattup2 (a, (b ,c, d, e)) = (a, b, c, d, e)

fun is_from (hdf : TermC.as_string) ((fmz_, spec) : Formalise.T) =

  hdf <> "" andalso fmz_ = [] andalso spec = References.empty

fun input_ ((dI, pI, mI): References.T) dtss = (*WN110515 reconsider thy..ctxt*)

  let

    val thy = ThyC.get_theory dI

	  val {ppc, ...} = Problem.from_store pI

	  val its_ = map (dtss2itm_ ppc) dtss (*([1],true,"#Given",Cor (...))*)

	  val its = O_Model.add_id its_

	  val pits = map flattup2 its

	  val (pI, mI) =

      if mI <> ["no_met"]

      then (pI, mI)

		  else

        case Refine.problem thy pI pits of

			    SOME (pI,_) => (pI, (hd o #met o Problem.from_store) pI)

			  | NONE => (pI, (hd o #met o Problem.from_store) pI)

	  val {ppc, pre, prls, ...} = Method.from_store mI

	  val its_ = map (dtss2itm_ ppc) dtss (*([1],true,"#Given",Cor (...))*)

	  val its = O_Model.add_id its_

	  val mits = map flattup2 its

	  val (_, pre) = Pre_Conds.check prls pre mits 0

    val ctxt = Proof_Context.init_global thy

  in (pI, pits, mI, mits, pre, ctxt) end;

(* check if the input term is a CAScmd and return a ctree with a _complete_ calchead *)

fun input hdt =

  let

    val (h, argl) = strip_comb hdt

  in

    case assoc_cas (ThyC.get_theory "Isac_Knowledge") h of

      NONE => NONE

    | SOME (spec as (dI,_,_), argl2dtss) =>

	      let

          val dtss = argl2dtss argl

	        val (pI, pits, mI, mits, pre, ctxt) = input_ spec dtss

	        val spec = (dI, pI, mI)

	        val (pt,_) = Ctree.cappend_problem Ctree.e_ctree [] (Istate_Def.empty, ContextC.empty)

		        ([], References.empty) ([], References.empty, hdt, ctxt)

	        val pt = Ctree.update_spec pt [] spec

	        val pt = Ctree.update_pbl pt [] pits

	        val pt = Ctree.update_met pt [] mits

	      in

	        SOME (pt, (true, Pos.Met, hdt, mits, pre, spec) : Specification.T)

	      end

  end

(**)end(**)