#!/usr/bin/env python2
#
#  Copyright (c) 2013 Insollo Entertainment, LLC.  All rights reserved.
#
#  Permission is hereby granted, free of charge, to any person obtaining a copy
#  of this software and associated documentation files (the "Software"),
#  to deal in the Software without restriction, including without limitation
#  the rights to use, copy, modify, merge, publish, distribute, sublicense,
#  and/or sell copies of the Software, and to permit persons to whom
#  the Software is furnished to do so, subject to the following conditions:
#
#  The above copyright notice and this permission notice shall be included
#  in all copies or substantial portions of the Software.
#
#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
#  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
#  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
#  IN THE SOFTWARE.
#
from __future__ import print_function
"""

This module generates state diagrams for all state machines found in nanomsg
source code.

Dependencies:

* python2.7
* python-clang
* graphviz (dot)

Invocation:

    make diagrams

To make code easier we make some assumtions about the code handing state
machine. We may lift some in the future. Important assumptions are:

* State machine code is handled by single function
* That function name is written literally in `nn_fsm_init`/`nn_fsm_init_root`
* Init call an function definition is in same source file
* State machine handled by nested switch statements
* Case labels contain `define`d constants written literally
* The `state` attribute is changed by assignment in the same file
* No `state` attributes are referenced in the function except FSM state


"""

import os
import sys
import subprocess
import errno

try:
    from clang.cindex import Index
except ImportError:
    sys.excepthook(*sys.exc_info())
    print(file=sys.stderr)
    print("It seems you don't have clang for python.", file=sys.stderr)
    print("You may try one of the following:", file=sys.stderr)
    print("    pip install clang", file=sys.stderr)
    print("    easy_install clang", file=sys.stderr)
    sys.exit(1)

HTML_HEADER = """
<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>nanomsg</title>
  <style>
  body {font-family:sans-serif;}
  #toplist {
    padding-left: 0px;
  }
  #toplist li {
    display: inline;
    list-style-type: none;
    padding-right: 15px;
  }
  a {color:#000000;}
  </style>
</head>
<body>
<div style="width:50em">

<img src="/logo.png">

<b>
<ul id='toplist'>
<li><a href="index.html">Home</a></li>
<li><a href="download.html">Download</a></li>
<li><a href="documentation.html">Documentation</a></li>
<li><a href="development.html">Development</a></li>
<li><a href="community.html">Community</a></li>
</ul>
</b>

<h2>State diagrams</h2>
"""

HTML_FOOTER = """
</div>
</body>
</html>
"""


def mkstate(stname):
    if '_STATE_' in stname:
        return stname.split('_STATE_')[1]
    if stname.startswith('NN_'):
        return stname[3:]
    return stname


def mksrc(src):
    if src is None:
        return '*'
    if '_SRC_' in src:
        return src.split('_SRC_')[1]
    if src.startswith('NN_'):
        return src[3:]
    return src


def mkaction(action):
    if action is None:
        return '*'
    if '_ACTION_' in action:
        return action.split('_ACTION_')[1]
    if action.startswith('NN_'):
        return action[3:]
    return action


class Visitor(object):

    def run(self, cursor):
        self.visit(cursor)

    def visit(self, cursor):
        try:
            name = cursor.kind.name
        except ValueError:
            name = 'VERY_BAD_NAME'
        meth = getattr(self, 'enter_' + name, None)
        if meth is not None:
            res = meth(cursor)
            if res is not None:
                return res.run(cursor)  # overrides visitor for subtree
        for i in cursor.get_children():
            self.visit(i)
        meth = getattr(self, 'exit_' + name, None)
        if meth is not None:
            meth(cursor)


class SkipVisitor(Visitor):
    """Returned from enter_xxx to skip checking subtree"""

    def run(self, cursor):
        pass


SKIP = Visitor()


class FindFSM(Visitor):

    def __init__(self):
        self.fsms = []

    def enter_CALL_EXPR(self, cursor):
        if cursor.displayname not in ('nn_fsm_init_root', 'nn_fsm_init'):
            return SKIP
        fname = list(cursor.get_children())[2]
        if fname.displayname:
            self.fsms.append(fname)
        # else: NULL is used in core/pipe.c

    def add_fsm(self, node):
        self.fsms.append(node)


class StateFinder(Visitor):

    def __init__(self):
        self.states = []

    def state_found(self, name, cursor):
        self.states.append((name, cursor))

    def visit(self, cursor):
        super(StateFinder, self).visit(cursor)

    def enter_CALL_EXPR(self, cursor):
        fun = list(cursor.get_children())[0].get_definition()
        if fun:
            sf = StateFinder()
            sf.run(fun)
            for name, cursor in sf.states:
                self.state_found(name, cursor)

    def enter_BINARY_OPERATOR(self, cursor):
        children = list(cursor.get_children())
        if children[0].displayname == 'state':  # tiny heuristic
            # Operator is the text between two children
            # Any better way to find out an operator?
            sr = cursor.extent
            with open(sr.start.file.name, 'rt') as f:
                oplen = (children[1].extent.start.offset -
                    children[0].extent.end.offset)
                vallen = (children[1].extent.end.offset -
                    children[1].extent.start.offset)
                f.seek(children[0].extent.end.offset)
                op = f.read(oplen).strip()
                val = f.read(vallen).strip()
            if op == '=':
                self.state_found(val, cursor)


class FSMScanner(StateFinder):

    def __init__(self):
        self.edges = set()
        self.running = {
            'state': None,
            'src': None,
            'type': None,
            }
        self.switch_stack = []

    def enter_SWITCH_STMT(self, cursor):
        ch = list(cursor.get_children())
        dn = ch[0].displayname
        if dn in self.running:
            assert self.running[dn] is None, (dn, self.running[dn])
        self.switch_stack.append(dn)

    def exit_SWITCH_STMT(self, cursor):
        ch = list(cursor.get_children())
        dn = ch[0].displayname
        top = self.switch_stack.pop()
        self.running[top] = None
        assert top == dn, (top, dn)  # Checking consistency of switch visits

    def enter_CASE_STMT(self, cursor):
        typ = self.switch_stack[-1]
        if typ in self.running:
            sr = list(cursor.get_children())[0].extent
            with open(sr.start.file.name, 'rt') as f:
                f.seek(sr.start.offset)
                const = f.read(sr.end.offset - sr.start.offset)
            self.running[typ] = const

    def enter_DEFAULT_STMT(self, cursor):
        typ = self.switch_stack[-1]
        if typ in self.running:
            self.running[typ] = '*'

    def state_found(self, state, cursor):
        r = self.running
        edge = (r['state'], r['src'], r['type'], state)
        if r['src'] is None or r['type'] is None:
            print('    Undefined state or action at {0.start.file}:{0.start.line}'
                .format(cursor.extent),
                file=sys.stderr)
        self.edges.add(edge)


index = None


def parse_file(fn):
    tu = index.parse(fn, sys.argv[1:])
    for i in tu.diagnostics:
        print(i, file=sys.stderr)
    finder = FindFSM()
    finder.run(tu.cursor)
    if finder.fsms:
        for func in finder.fsms:
            scan = FSMScanner()
            scan.run(func.get_definition())
            targetfn = os.path.join('doc/diagrams', func.displayname + '.png')
            print("Writing", targetfn, 'from', fn, file=sys.stderr)
            print("<h3>", func.displayname, "</h3>")
            print("<p>Source file:", fn, "</p>")
            print('<p><img src="diagrams/{}.png" border=0></p>'
                .format(func.displayname))
            lines = []
            for fromstate, src, action, tostate in scan.edges:
                if fromstate is None: continue  # Not implemented well
                if src == 'NN_FSM_ACTION':
                    lines.append('{} -> {} [label="[{}]"]'.format(
                        mkstate(fromstate),
                        mkstate(tostate),
                        mkaction(action)))
                else:
                    lines.append('{} -> {} [label="{}:{}"]'.format(
                        mkstate(fromstate),
                        mkstate(tostate),
                        mksrc(src),
                        mkaction(action)))
            data = 'digraph G {' + '\n'.join(lines) + '}'
            try:
                subprocess.Popen(['dot', '-Tpng', '-o', targetfn],
                    stdin=subprocess.PIPE).communicate(data)
            except OSError as e:
                sys.excepthook(*sys.exc_info())
                if e.errno == errno.ENOENT:
                    print(file=sys.stderr)
                    print("It seems you dont have `dot`", file=sys.stderr)
                    print("You may wish to try:", file=sys.stderr)
                    print("    apt-get install graphviz", file=sys.stderr)
                sys.exit(1)


def main():
    global index

    index = Index.create()
    script_dir = os.path.abspath(os.path.dirname(os.path.realpath(sys.argv[0])) + '/../')

    with open('doc/diagrams.html', 'wt') as f:
        sys.stdout = f
        print(HTML_HEADER)
        for dirpath, dirs, files in os.walk(os.path.join(script_dir,'src' )):
            for f in files:
                if not f.endswith('.c'):
                    continue
                parse_file(os.path.join(dirpath, f))
        print(HTML_FOOTER)


if __name__ == '__main__':
    main()