(* Title:  Specify/step-specify.sml

   Author: Walther Neuper 2019

   (c) due to copyright terms

*)

signature STEP_SPECIFY =

sig

(*val do_next: Step.specify_do_next requires LI.by_tactic, which is not yet known in Step_Specify*)

  val by_tactic_input: Tactic.input -> Calc.T -> Chead.calcstate'

  val by_tactic: Tactic.T -> Calc.T -> string * Chead.calcstate'

(* ---- keep, probably required later in devel. ----------------------------------------------- *)

  val nxt_specify_init_calc: Selem.fmz

    -> Calc.T * (Tactic.input * Tactic.T * (Pos.pos' * (Istate_Def.T * Proof.context))) list

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

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

end

(**)

structure Step_Specify(**): STEP_SPECIFY(**) =

struct

(**)

open Pos

open Ctree

open Chead

(* was fun Math_Engine.nxt_specify_ *)

fun by_tactic_input (tac as Tactic.Model_Problem) (pt, pos as (p, _)) =

    let

      val (oris, ospec, probl, spec, ctxt) = case get_obj I pt p of

        PblObj {origin = (oris, ospec, _), probl, spec, ctxt, ...} => (oris, ospec, probl, spec, ctxt)

      | _ => error "by_tactic_input Model_Problem; uncovered case get_obj"

      val (dI, pI, mI) = some_spec ospec spec

      val thy = Celem.assoc_thy dI

      val mpc = (#ppc o Specify.get_met) mI (* just for reuse complete_mod_ *)

      val {cas, ppc, ...} = Specify.get_pbt pI

      val pbl = Generate.init_pbl ppc (* fill in descriptions *)

      (*----------------if you think, this should be done by the Dialog 

       in the java front-end, search there for WN060225-modelProblem----*)

      val (pbl, met) = case cas of

        NONE => (pbl, [])

  		| _ => complete_mod_ (oris, mpc, ppc, probl)

      (*----------------------------------------------------------------*)

      val tac_ = Tactic.Model_Problem' (pI, pbl, met)

      val (pos,c,_,pt) = Generate.generate1 tac_ (Istate_Def.Uistate, ctxt) (pt, pos)

    in ([(tac, tac_, (pos, (Istate_Def.Uistate, ContextC.empty)))], c, (pt,pos)) end

  | by_tactic_input (Tactic.Add_Given ct) ptp = nxt_specif_additem "#Given" ct ptp

  | by_tactic_input (Tactic.Add_Find  ct) ptp = nxt_specif_additem "#Find"  ct ptp

  | by_tactic_input (Tactic.Add_Relation ct) ptp = nxt_specif_additem"#Relate" ct ptp

    (*. called only if no_met is specified .*)     

  | by_tactic_input (Tactic.Refine_Tacitly pI) (ptp as (pt, pos as (p, _))) =

    let 

      val (oris, dI, ctxt) = case get_obj I pt p of

        (PblObj {origin = (oris, (dI, _, _), _), ctxt, ...}) => (oris, dI, ctxt)

      | _ => error "by_tactic_input Refine_Tacitly: uncovered case get_obj"

      val opt = Specify.refine_ori oris pI

    in 

      case opt of

	      SOME pI' => 

	        let 

            val {met, ...} = Specify.get_pbt pI'

	          (*val pt = update_pbl pt p pbl ..done by Model_Problem*)

	          val mI = if length met = 0 then Celem.e_metID else hd met

            val thy = Celem.assoc_thy dI

	          val (pos, c, _, pt) = 

		          Generate.generate1 (Tactic.Refine_Tacitly' (pI, pI', dI, mI,(*pbl*)[])) (Istate_Def.Uistate, ctxt) (pt, pos)

	        in

	          ([(Tactic.Refine_Tacitly pI, Tactic.Refine_Tacitly' (pI,pI',dI,mI,(*pbl*)[]),

	              (pos, (Istate_Def.Uistate, ContextC.empty)))], c, (pt,pos)) 

          end

	    | NONE => ([], [], ptp)

    end

  | by_tactic_input (Tactic.Refine_Problem pI) (ptp as (pt, pos as (p,_))) =

    let

      val (dI, dI', probl, ctxt) = case get_obj I pt p of

        PblObj {origin= (_, (dI, _, _), _), spec = (dI', _, _), probl, ctxt, ...} =>

          (dI, dI', probl, ctxt)

      | _ => error "by_tactic_input Refine_Problem: uncovered case get_obj"

	    val thy = if dI' = Rule.e_domID then dI else dI'

    in 

      case Specify.refine_pbl (Celem.assoc_thy thy) pI probl of

	      NONE => ([], [], ptp)

	    | SOME rfd => 

	      let 

          val (pos,c,_,pt) = Generate.generate1 (Tactic.Refine_Problem' rfd) (Istate_Def.Uistate, ctxt) (pt, pos)

	      in

	        ([(Tactic.Refine_Problem pI, Tactic.Refine_Problem' rfd, (pos, (Istate_Def.Uistate, ContextC.empty)))], c, (pt,pos))

        end

    end

  | by_tactic_input (Tactic.Specify_Problem pI) (pt, pos as (p,_)) =

    let

      val (oris, dI, dI', pI', probl, ctxt) = case get_obj I pt p of

        PblObj {origin = (oris, (dI,_,_),_), spec = (dI',pI',_), probl, ctxt, ...} =>

          (oris, dI, dI', pI', probl, ctxt)

      | _ => error ""

	    val thy = Celem.assoc_thy (if dI' = Rule.e_domID then dI else dI');

      val {ppc,where_,prls,...} = Specify.get_pbt pI

	    val pbl = 

	      if pI' = Celem.e_pblID andalso pI = Celem.e_pblID

	      then (false, (Generate.init_pbl ppc, []))

	      else Specify.match_itms_oris thy probl (ppc,where_,prls) oris

	      (*FIXXXME~~~~~~~~~~~~~~~: take pbl and compare with new pI WN.8.03*)

	    val (c, pt) =

	      case Generate.generate1 (Tactic.Specify_Problem' (pI, pbl)) (Istate_Def.Uistate, ctxt) (pt, pos) of

  	      ((_, Pbl), c, _, pt) => (c, pt)

  	    | _ => error ""

    in

      ([(Tactic.Specify_Problem pI, Tactic.Specify_Problem' (pI, pbl), (pos, (Istate_Def.Uistate, ContextC.empty)))], c, (pt, pos))

    end

  (* transfers oris (not required in pbl) to met-model for script-env

     FIXME.WN.8.03: application of several mIDs to SAME model?       *)

  | by_tactic_input (Tactic.Specify_Method mID) (pt, pos as (p,_)) = 

    let

      val (oris, pbl, dI, met, ctxt) = case get_obj I pt p of

        PblObj {origin = (oris, _, _), probl = pbl, spec = (dI, _, _), meth=met, ctxt, ...}

          => (oris, pbl, dI, met, ctxt)

      | _ => error "by_tactic_input Specify_Method: uncovered case get_obj"

      val {ppc,pre,prls,...} = Specify.get_met mID

      val thy = Celem.assoc_thy dI

      val oris = Specify.add_field' thy ppc oris

      val met = if met=[] then pbl else met (* WN0602 what if more itms in met? *)

      val (_, (itms, _)) = Specify.match_itms_oris thy met (ppc,pre,prls ) oris

      val itms = Specify.hack_until_review_Specify_2 mID itms

      val (pos, c, _, pt) = 

	      Generate.generate1 (Tactic.Specify_Method' (mID, oris, itms)) (Istate_Def.Uistate, ctxt) (pt, pos)

    in

      ([(Tactic.Specify_Method mID, Tactic.Specify_Method' (mID, oris, itms), (pos, (Istate_Def.Uistate, ContextC.empty)))], c, (pt, pos)) 

    end    

  | by_tactic_input (Tactic.Specify_Theory dI) (pt, pos as (_, Pbl)) =

    let

      val ctxt = get_ctxt pt pos

	    val (pos, c, _, pt) = 

	      Generate.generate1 (Tactic.Specify_Theory' dI)  (Istate_Def.Uistate, ctxt) (pt, pos)

    in (*FIXXXME: check if pbl can still be parsed*)

	    ([(Tactic.Specify_Theory dI, Tactic.Specify_Theory' dI, (pos, (Istate_Def.Uistate, ctxt)))], c,

	      (pt, pos))

    end

  | by_tactic_input (Tactic.Specify_Theory dI) (pt, pos as (_, Met)) =

    let

      val ctxt = get_ctxt pt pos

	    val (pos, c, _, pt) = Generate.generate1 (Tactic.Specify_Theory' dI) (Istate_Def.Uistate, ctxt) (pt, pos)

    in  (*FIXXXME: check if met can still be parsed*)

	    ([(Tactic.Specify_Theory dI, Tactic.Specify_Theory' dI, (pos, (Istate_Def.Uistate, ctxt)))], c, (pt, pos))

    end

  | by_tactic_input m' _ = error ("by_tactic_input: not impl. for " ^ Tactic.input_to_string m')

(* was fun Math_Engine.nxt_specify_ *)

(* was fun Chead.specify *)

fun by_tactic (Tactic.Init_Proof' (fmz, spec' as (dI', pI', mI'))) _ = 

    let          (* either """"""""""""""" all empty or complete *)

      val thy = Celem.assoc_thy dI'

      val (oris, ctxt) = 

        if dI' = Rule.e_domID orelse pI' = Celem.e_pblID  (*andalso? WN110511*)

        then ([], ContextC.empty)

  	    else pI' |> #ppc o Specify.get_pbt |> Specify.prep_ori fmz thy

        (* these are deprecated                vvvvvvvvvvvvvvvvvvvvvvvvvv*)

      val (pt, _) = cappend_problem e_ctree [] (Istate_Def.empty, ContextC.empty) (fmz, spec')

  			(oris, (dI',pI',mI'), Rule.e_term, ctxt)

      val pt = update_loc' pt [] (SOME (Istate_Def.empty, ctxt), NONE)

    in 

      case mI' of

  	    ["no_met"] => ("Refine_Tacitly", ([], [], (pt, ([], Pbl))))

      | _ => ("ok", ([], [], (pt, ([], Pbl))))

    end

    (* ONLY for STARTING modeling phase *)

  | by_tactic (Tactic.Model_Problem' (_, pbl, met)) (pt, pos as (p, _))  =

    let 

      val (oris, dI',pI',mI', dI, ctxt) = case get_obj I pt p of

        PblObj {origin= (oris, (dI', pI', mI'), _), spec= (dI, _, _), ctxt, ...} =>

          (oris, dI',pI',mI', dI, ctxt)

      | _ => error "Step_Solve.by_tactic (Model_Problem': uncovered case get_obj"

      val thy' = if dI = Rule.e_domID then dI' else dI

      val thy = Celem.assoc_thy thy'

      val {ppc, prls, where_, ...} = Specify.get_pbt pI'

      val pre = Stool.check_preconds thy prls where_ pbl

      val pb = foldl and_ (true, map fst pre)

      val ((p, _), _, _, pt) =

        Generate.generate1 (Tactic.Model_Problem'([],pbl,met)) (Istate_Def.Uistate, ctxt) (pt, pos)

      val (_, _) = Chead.nxt_spec Pbl pb oris (dI', pI', mI') (pbl, met) 

		    (ppc,(#ppc o Specify.get_met) mI') (dI',pI',mI');

    in

      ("ok", ([], [], (pt, (p, Pbl))))

    end

    (* called only if no_met is specified *)     

  | by_tactic (Tactic.Refine_Tacitly' (pI, pIre, _, _, _)) (pt, pos) =

      let

(*      val (dI', ctxt) = case get_obj I pt p of

          PblObj {origin= (_, (dI', _, _), _), ctxt, ...} => (dI', ctxt)

        | _ => error "Step_Solve.by_tactic (Refine_Tacitly': uncovered case get_obj"*)

        val {met, thy,...} = Specify.get_pbt pIre

        val (domID, metID) = (Rule.string_of_thy thy, if length met = 0 then Celem.e_metID else hd met)

        val ((p,_), _, _, pt) = 

	        Generate.generate1 (Tactic.Refine_Tacitly' (pI, pIre, domID, metID, [(*pbl*)]))

            (Istate_Def.Uistate, ContextC.empty) (pt, pos)

(* deprecated^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ *)

(*     val (pbl, pre, _) = ([], [], false)*)

      in 

        ("ok", ([], [], (pt,(p, Pbl))))

      end

  | by_tactic (Tactic.Refine_Problem' rfd) (pt, pos)  =

      let

        val ctxt = get_ctxt pt pos

        val (pos, _, _, pt) =

          Generate.generate1 (Tactic.Refine_Problem' rfd) (Istate_Def.Uistate, ctxt) (pt, pos)

      in

        ("ok", ([], [], (pt,pos)))

      end

    (*WN110515 initialise ctxt again from itms and add preconds*)

  | by_tactic (Tactic.Specify_Problem' (pI, (ok, (itms, pre)))) (pt, pos as (p, _)) =

      let

        val (_, _, _, _, dI, _, ctxt, _) = case get_obj I pt p of

          PblObj {origin= (oris, (dI', pI', mI'), _), spec= (dI, _, mI), ctxt, meth = met, ...} =>

            (oris, dI', pI', mI', dI, mI, ctxt, met)

        | _ => error "Step_Solve.by_tactic (Specify_Problem': uncovered case get_obj"

        val thy = Celem.assoc_thy dI

        val (p, pt) =

          case  Generate.generate1 (Tactic.Specify_Problem' (pI, (ok, (itms, pre)))) (Istate_Def.Uistate, ctxt) (pt, pos) of

            ((p, Pbl), _, _, pt) => (p, pt)

          | _ => error "Step_Solve.by_tactic (Specify_Problem': uncovered case generate1 (WARNING WHY ?)"

      in

        ("ok", ([], [], (pt, (p, Pbl))))

      end    

    (*WN110515 initialise ctxt again from itms and add preconds*)

  | by_tactic (Tactic.Specify_Method' (mID, _, _)) (pt,pos as (p, _)) =

      let

        val (oris, _, _, mI', dI, _, pbl, met, ctxt) = case get_obj I pt p of

          PblObj {origin= (oris, (dI', pI', mI'), _), spec= (dI, pI, _), probl = pbl, meth = met, ctxt, ...} =>

             (oris, dI', pI', mI', dI, pI, pbl, met, ctxt)

        | _ => error "Step_Solve.by_tactic (Specify_Problem': uncovered case get_obj"

        val {ppc, pre, prls,...} = Specify.get_met mID

        val thy = Celem.assoc_thy dI

        val oris = Specify.add_field' thy ppc oris

        val met = if met = [] then pbl else met

        val (_, (itms, _)) = Specify.match_itms_oris thy met (ppc, pre, prls) oris

        val itms = Specify.hack_until_review_Specify_1 mI' itms

        val (pos, _, _, pt) = 

	        Generate.generate1 (Tactic.Specify_Method' (mID, oris, itms)) (Istate_Def.Uistate, ctxt) (pt, pos)

      in

        ("ok", ([], [], (pt, pos)))

      end    

  | by_tactic (Tactic.Add_Given' (ct, _)) (pt, p)  = Chead.specify_additem "#Given" ct (pt, p)

  | by_tactic (Tactic.Add_Find'  (ct, _)) (pt, p) = Chead.specify_additem "#Find" ct (pt, p)

  | by_tactic (Tactic.Add_Relation' (ct, _)) (pt, p) = Chead.specify_additem"#Relate" ct (pt, p)

  | by_tactic (Tactic.Specify_Theory' domID) (pt, (p,p_)) =

      let

        val p_ = case p_ of Met => Met | _ => Pbl

        val thy = Celem.assoc_thy domID

        val (oris, dI', pI', mI', dI, pI, mI, pbl, met, ctxt) = case get_obj I pt p of

          PblObj {origin= (oris, (dI', pI', mI'), _), spec= (dI, pI, mI), probl = pbl, meth = met, ctxt, ...} =>

             (oris, dI', pI', mI', dI, pI, mI, pbl, met, ctxt)

        | _ => error "Step_Solve.by_tactic (Specify_Theory': uncovered case get_obj"

        val _ = case p_ of Met => met | _ => pbl

        val cpI = if pI = Celem.e_pblID then pI' else pI

        val {prls = per, ppc, where_ = pwh, ...} = Specify.get_pbt cpI

        val cmI = if mI = Celem.e_metID then mI' else mI

        val {prls = mer, ppc = mpc, pre= mwh, ...} = Specify.get_met cmI

        val pre = case p_ of

          Met => (Stool.check_preconds thy mer mwh met)

        | _ => (Stool.check_preconds thy per pwh pbl)

        val pb = foldl and_ (true, map fst pre)

      in

        if domID = dI

        then

          let val (p_, _) = nxt_spec p_ pb oris (dI', pI', mI') (pbl, met) (ppc, mpc) (dI, pI, mI)

	        in

            ("ok", ([], [], (pt, (p, p_))))

          end

        else (*FIXME: check ppc wrt. (new!) domID ..? still parsable?*)

	        let 

	          val ((p, p_), _, _, pt) = Generate.generate1 (Tactic.Specify_Theory' domID) (Istate_Def.Uistate, ctxt) (pt, (p,p_))

	          val (p_, _) = nxt_spec p_ pb oris (dI', pI', mI') (pbl, met) (ppc, mpc) (domID, pI, mI)

	        in

            ("ok", ([], [], (pt, (p, p_))))

          end

      end

  | by_tactic _ _ = raise ERROR "Step_Specify.by_tactic uncovered pattern in fun.def"

(* was fun Chead.specify *)

(* create a calc-tree with oris via an cas.refined pbl *)

fun nxt_specify_init_calc ([], (dI, pI, mI)) =

    if pI <> [] 

    then (* from pbl-browser or from CAS cmd with pI=[e_pblID] *)

	    let 

        val {cas, met, ppc, thy, ...} = Specify.get_pbt pI

	      val dI = if dI = "" then Rule.theory2theory' thy else dI

	      val mI = if mI = [] then hd met else mI

	      val hdl = case cas of NONE => Auto_Prog.pblterm dI pI | SOME t => t

	      val (pt,_) = cappend_problem e_ctree [] (Istate_Def.Uistate, ContextC.empty) ([], (dI, pI, mI))

				  ([], (dI,pI,mI), hdl, ContextC.empty)

	      val pt = update_spec pt [] (dI, pI, mI)

	      val pits = Generate.init_pbl' ppc

	      val pt = update_pbl pt [] pits

	    in ((pt, ([] , Pbl)), []) end

    else 

      if mI <> [] 

      then (* from met-browser *)

	      let 

          val {ppc, ...} = Specify.get_met mI

	        val dI = if dI = "" then "Isac_Knowledge" else dI

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

	          ([], (dI, pI, mI)) ([], (dI, pI, mI), Rule.e_term, ContextC.empty)

	        val pt = update_spec pt [] (dI, pI, mI)

	        val mits = Generate.init_pbl' ppc

	        val pt = update_met pt [] mits

	      in ((pt, ([], Met)), []) end

      else (* new example, pepare for interactive modeling *)

	      let

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

	          ([], Celem.e_spec) ([], Celem.e_spec, Rule.e_term, ContextC.empty)

	      in ((pt, ([], Pbl)), []) end

  | nxt_specify_init_calc (fmz, (dI, pI, mI)) = 

    let           (* both """"""""""""""""""""""""" either empty or complete *)

	    val thy = Celem.assoc_thy dI

	    val (pI, (pors, pctxt), mI) = 

	      if mI = ["no_met"] 

	      then 

          let 

            val (pors, pctxt) = Specify.get_pbt pI |> #ppc |> Specify.prep_ori fmz thy;

		        val pI' = Specify.refine_ori' pors pI;

		      in (pI', (pors(*refinement over models with diff.precond only*), pctxt),

		        (hd o #met o Specify.get_pbt) pI')

		      end

	      else (pI, Specify.get_pbt pI |> #ppc |> Specify.prep_ori fmz thy, mI)

	    val {cas, ppc, thy = thy', ...} = Specify.get_pbt pI (*take dI from _refined_ pbl*)

	    val dI = Rule.theory2theory' (Stool.common_subthy (thy, thy'))

	    val hdl = case cas of

		    NONE => Auto_Prog.pblterm dI pI

		  | SOME t => subst_atomic ((vars_of_pbl_' ppc) ~~~ vals_of_oris pors) t

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

        (fmz, (dI, pI, mI)) (pors, (dI, pI, mI), hdl, pctxt)

    in

      ((pt, ([], Pbl)), fst3 (by_tactic_input Tactic.Model_Problem (pt, ([], Pbl))))

    end

(**)end(**)