// Copyright (c) 2013 Justus Winter <4winter@informatik.uni-hamburg.de>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package nusmv

import (
    "fmt"
    "io"
    "regexp"
    "strings"
    "text/template"
    "vgo/human"
    "vgo/logic"
    "vgo/verification"
)

func writeSMV(w io.Writer, t *template.Template, m verification.Model, f []logic.Formula) (*smvContext, error) {
    c := &smvContext{
        Model:    m,
        formulas: f,
        atomMap:  make(human.StringIds),
    }
    return c, t.Execute(w, c)
}

func WriteSMV(m verification.Model, w io.Writer, f []logic.Formula) (err error) {
    _, err = writeSMV(w, smvTemplate, m, f)
    return
}

func WriteSMVMin(w io.Writer, m verification.Model, f []logic.Formula) (err error) {
    _, err = writeSMV(w, smvTemplateMin, m, f)
    return
}

type smvContext struct {
    verification.Model
    formulas []logic.Formula
    atomMap  human.StringIds
}

func (s *smvContext) States() int {
    return len(s.Model.Nodes())
}

func (s *smvContext) Transitions() string {
    r := make([]string, 0, len(s.Model.Edges()))
    for _, e := range s.Model.Edges() {
        r = append(r, fmt.Sprintf("(_=%v&next(_)=%v)", e.From, e.To))
    }
    return strings.Join(r, "|")
}

func (s *smvContext) Vars() (r []atom) {
    for _, a := range s.Model.Atoms() {
        r = append(r, s.atom(a))
    }
    return
}

func (s *smvContext) Formulas() (r []string) {
    for _, f := range s.formulas {
        r = append(r, s.smvFormula(f))
    }
    return
}

type atom struct {
    *smvContext
    *logic.AtomicProposition
}

func (a atom) String() string {
    return fmt.Sprintf("a%v", a.smvContext.atomMap.Map(a.Symbol()))
}

const caseDefault = "TRUE:FALSE;"

func (a atom) Assignment() string {
    r := make([]string, 0, a.Model.Len())

    for n, _ := range a.Model.Nodes() {
        if a.Model.EvaluateAtom(n, a.AtomicProposition) {
            r = append(r, fmt.Sprintf("_=%v", n))
        }
    }

    if len(r) == 0 {
        return caseDefault
    }

    return fmt.Sprintf("%v:TRUE;"+caseDefault, strings.Join(r, "|"))
}

func (s *smvContext) atom(a *logic.AtomicProposition) atom {
    return atom{s, a}
}

func (s *smvContext) smvFormula(f logic.Formula) string {
    symbol := f.Symbol()
    switch n := f.(type) {
    case *logic.AtomicProposition:
        return " " + s.atom(n).String()
    case *logic.Constant:
        if n == logic.Top {
            return "TRUE"
        }
        return "FALSE"
    case *logic.Not:
        symbol = "!"
    case *logic.Or:
        symbol = "|"
    case *logic.And:
        symbol = "&"
    case *logic.Until:
        return fmt.Sprintf("[%v U %v]", s.smvFormula(f.Operands()[0]), s.smvFormula(f.Operands()[1]))
    case *logic.ForAll:
        if o, ok := f.Operands()[0].(*logic.Release); ok {
            return fmt.Sprintf("!E [!%v U !%v]", s.smvFormula(o.Operands()[0]), s.smvFormula(o.Operands()[1]))
        }

        return " A" + s.smvFormula(f.Operands()[0])
    case *logic.Exists:
        if o, ok := f.Operands()[0].(*logic.Release); ok {
            return fmt.Sprintf("!A [!%v U !%v]", s.smvFormula(o.Operands()[0]), s.smvFormula(o.Operands()[1]))
        }

        return " E" + s.smvFormula(f.Operands()[0])
    }

    o := f.Operands()
    switch len(o) {
    case 1:
        return fmt.Sprintf("%s%s", symbol, s.smvFormula(o[0]))
    case 2:
        return fmt.Sprintf("(%s %s %s)", s.smvFormula(o[0]), symbol, s.smvFormula(o[1]))
    }

    panic("Not reached")
}

var smvTemplate, smvTemplateMin *template.Template

func init() {
    m := "MODULE main\n"
    smvTemplate = template.Must(template.New("smv").Parse(m + smvTemplateString))

    norm := regexp.MustCompile(`\s+`)
    min := regexp.MustCompile(` ?([:;=]) ?`)

    t := norm.ReplaceAllString(smvTemplateString, " ")
    t = min.ReplaceAllString(t, "$1")
    t = strings.TrimSpace(t)

    smvTemplateMin = template.Must(template.New("smvmin").Parse(m + t))
}

const smvTemplateString = `
VAR
  _: 0..{{.States}};
{{range .Vars}}  {{.}}: boolean;
{{end}}

TRANS
  {{.Transitions}};

ASSIGN
  init(_) := 0;
{{range .Vars}}  {{.}} := case
    {{.Assignment}}
  esac;
{{end}}

{{range .Formulas}}
CTLSPEC {{.}};
{{end}}
`