#!/usr/bin/env python
'''
patch MPS Logic files


usage:
mpslogicpatch <MPL File> <patch 1> <patch 2> ...


Example File Contents
=====================
[
    {
        "name": "OTR30 Position",
        "inputs": [
            "OTR30_0449_OUT_STATE",
            "OTR30_0449_IN_STATE"
        ],
        "ignore_when": [
            "YG BL211 Is In"
        ],
        "states": [
            [0, "Moving",   0,   0,   0, null],
            [1, "Out",    120, 120, 120, null],
            [2, "In",       0,   0,   0, null],
            [3, "Broken",   0,   0,   0, null]
        ]
    },
    {
        "name": "OTR33 Position",
        "inputs": [
            "OTR33_0745_OUT_STATE",
            "OTR33_0745_IN_STATE"
        ],
        "ignore_when": [
            "YG BL211 Is In",
            "TD11 Is In",
            "TDUND Is In"
        ],
        "states": [
            [0, "Moving",   0,   0,   0, null],
            [1, "Out",    120, 120, 120, null],
            [2, "In",       0,   0,   0, null],
            [3, "Broken",   0,   0,   0, null]
        ]
    }
]
'''

import sys
import os
import json
import sqlite3
import re
from pprint import pprint


def indent(string, amount=4):
    line_start = re.compile(r'^', re.MULTILINE)
    return re.sub(line_start, ' ' * amount, string)


class Mpl(object):
    def __init__(self, mpl_cursor):
        self.cursor = mpl_cursor
    
    def ignore_macros(self):
        '''
        Return a dictionary of ignore macros
        {'macro_name': macro_pk, ... }
        '''
        self.cursor.execute(
            '''
            select
                m.ZNAME name,
                i.Z_PK pk
            from
                ZIGNOREMACRO i inner join 
                ZMACRO       m on i.ZMACRO == m.Z_PK
            '''
        )
        return dict(self.cursor.fetchall())
    
    def devices(self):
        '''
        Return a dictionary of device names
        {'device_name': device_pk, ... }
        '''
        self.cursor.execute('select ZNAME, Z_PK from ZDEVICE')
        return dict(self.cursor.fetchall())
    
    def rates(self):
        '''
        Return a dictionary of rates
        {
              0: rate_0_hz_pk,
            120: rate_120_hz_pk,
           None: rate_ignore_pk
        }
        '''
        self.cursor.execute('select ZNAME, Z_PK from ZRATE')
        r = dict(self.cursor.fetchall())
        rd = {
            'ignore': r['Ignore'],
            'burst': r['Burst Mode'],
            'single': r['Single Shot'],
            0: r['0 Hz'],
            10: r['10 Hz'],
            30: r['30 Hz'],
            60: r['60 Hz'],
            120: r['120 Hz'],
            None: r['Ignore']
        }
        return rd
    
    def mitigation_devices(self):
        '''
        Return a dictionary of mitigation device pks
        '''
        self.cursor.execute('select ZNAME, Z_PK from ZMITIGATIONDEVICE')
        return dict(self.cursor.fetchall())        
    

def table_zent_zopt(mpl_cursor, table):
    mpl_cursor.execute('select Z_ENT, Z_OPT from {0}'.format(table))
    return mpl_cursor.fetchone()


class MplError(Exception):
    def __init__(self, err_str):
        self.err_str = err_str
    def __str__(self):
        return self.err_str


def verify_patch(mpl_cursor, patch):
    mpl = Mpl(mpl_cursor)
    ignore_macros = mpl.ignore_macros()
    
    for tt in patch:
        # Check if truth table name already exists
        mpl_cursor.execute('select count(*) from ZMACRO where ZNAME=?', (tt['name'],))
        name_count = int(mpl_cursor.fetchone()[0])
        if name_count:
            raise MplError('Truth table "{0}" already in MPL file'.format(tt['name']))

        # Check if input devices are valid
        for device in tt['inputs']:
            mpl_cursor.execute('select count(*) from ZDEVICE where ZNAME=?', (device,))
            device_count = int(mpl_cursor.fetchone()[0])
            if device_count != 1:
                raise MplError('Unknown input "{0}" for {1}'.format(device, tt['name']))
        
        # Check if ignore conditions are valid
        for ignore in tt['ignore_when']:
            if ignore not in ignore_macros:
                raise MplError('Unknown ignore condition "{0}" for {1}'.format(ignore, tt['name']))
        
        # Check states
        number_of_states = 2 ** len(tt['inputs'])
        state_number_set = set(xrange(0, number_of_states))
        for state in tt['states']:
            (number, name, pc, bykik, ms, lhs) = state
            try:
                state_number_set.remove(number)
            except KeyError:
                raise MplError('Invalid state number, {0}, in {1}'.format(number, tt['name']))
            
            for rate in zip(('Pockels Cell', 'Mechanical Shutter', 'BYKIK', 'Laser Heater Shutter'), (pc, ms, bykik, lhs)):
                if rate[1] not in (0, 120, None):
                    raise MplError('Invalid {0} rate for state "{1}" in {2}'.format(rate[0], name, tt['name']))
                
        if state_number_set:
            raise MplError('Undefined states ({0}) in {1}'.format(', '.join(str(s) for s in state_number_set), tt['name']))
                    

def apply_patches(mpl_cursor, patch):
    # Store some static values
    mpl = Mpl(mpl_cursor)
    ignore_macros = mpl.ignore_macros()
    devices = mpl.devices()
    rates = mpl.rates()
    mit_devs = mpl.mitigation_devices()
    mit_keys = ('Pockels Cell', 'Mechanical Shutter', 'BYKIK', 'Laser Heater Shutter')

    for tt in patch:
        # Add the truth table
        (zent, zopt) = table_zent_zopt(mpl_cursor, 'ZMACRO')
        name = tt['name']
        print 'Adding {0}'.format(name)
        query = 'insert into ZMACRO (Z_ENT, Z_OPT, ZISACTIVE, ZNAME) values (?, ?, ?, ?)'
        mpl_cursor.execute(query, (zent, zopt, 1, name))
        macro_pk = mpl_cursor.lastrowid
        print indent('Added truth table "{0}" ({1})'.format(name, macro_pk))

        # Add the ignore macros
        (zent, zopt) = table_zent_zopt(mpl_cursor, 'ZMACROOPTOUT')
        query = 'insert into ZMACROOPTOUT (Z_ENT, Z_OPT, ZMACRO, ZIGNOREMACRO) values (?, ?, ?, ?)'
        for ignore in tt['ignore_when']:
            ignore_fk = ignore_macros[ignore]
            mpl_cursor.execute(query, (zent, zopt, macro_pk, ignore_fk))
            print indent('Ignored when {0}'.format(ignore))
        
        # Add inputs
        (zent, zopt) = table_zent_zopt(mpl_cursor, 'ZMACROINPUT')
        query = 'insert into ZMACROINPUT (Z_ENT, Z_OPT, ZMACRO, ZPOSITION, ZDEVICE) values (?, ?, ?, ?, ?)'
        for i, device in enumerate(tt['inputs']):
            mpl_cursor.execute(query, (zent, zopt, macro_pk, i, devices[device]))
            print indent('Input {0}: {1}'.format(i, device))
        
        # Add states
        (state_zent, state_zopt) = table_zent_zopt(mpl_cursor, 'ZMACROSTATE')
        (rate_zent, rate_zopt) = table_zent_zopt(mpl_cursor, 'ZMACROSTATERATEATDEVICE')
        state_query = 'insert into ZMACROSTATE (Z_ENT, Z_OPT, ZISDEFAULT, ZNUMBER, ZMACRO, ZNAME) values (?, ?, ?, ?, ?, ?)'
        rate_query = 'insert into ZMACROSTATERATEATDEVICE (Z_ENT, Z_OPT, ZSTATE, ZDEVICE, ZRATE) values (?, ?, ?, ?, ?)'
        for state in tt['states']:
            (number, name, pc, bykik, ms, lhs) = state            
            mpl_cursor.execute(state_query, (state_zent, state_zopt, 0, number, macro_pk, name))
            state_pk = mpl_cursor.lastrowid
            print indent('Adding state "{0}"'.format(name))
            
            for (k, v) in zip(mit_keys, (pc, bykik, ms, lhs)):
                mpl_cursor.execute(rate_query, (rate_zent, rate_zopt, state_pk, mit_devs[k], rates[v]))
                print indent('{0}: {1}'.format(k, v), 8)
            
    
def usage():
    sys.stderr.write('mpslogicpatch <MPL File> <patch 1> <patch 2> ...\n')


def main(argv=None):
    if len(argv) < 2:
        usage()
        return 1    

    mpl_path = argv[0]
    patch_paths = argv[1:]
    
    try:
        connection = sqlite3.connect(mpl_path)
        connection.row_factory = sqlite3.Row
        mpl_cursor = connection.cursor()

        for patch_path in patch_paths:
            with open(patch_path) as p:
                patch = json.load(p)
                verify_patch(mpl_cursor, patch)
                apply_patches(mpl_cursor, patch)

        connection.commit()
    except MplError as e:
        print e
    finally:
        connection.close()

    return 0



if __name__ == '__main__':
    status = main(sys.argv[1:])
    sys.exit(status)


