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

example_patch_file = '''
Example Patch (JSON Format)::

    {
        "version": "1",
        "truth_tables": [
            {
                "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]
                ]
            }
        ]
    }
'''

__doc__ = '\n'.join((__doc__, example_patch_file))

import sys
import os
import re
import json
import sqlite3
import argparse


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_truth_tables(mpl_cursor, truth_tables):
    mpl = Mpl(mpl_cursor)
    ignore_macros = mpl.ignore_macros()
    rates = mpl.rates()
    
    for tt in truth_tables:
        # 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.get('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 rates:
                    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_truth_tables(mpl_cursor, truth_tables):
    # 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 truth_tables:
        # 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.get('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 process_args(argv=None):
    if argv is None:
        argv = sys.argv[1:]
    
    parser = argparse.ArgumentParser(description='patch MPS Logic files.', formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.epilog = example_patch_file

    parser.add_argument('-v', '--version', action='version', version='%(prog)s 1.0')

    parser.add_argument(
        'mpl', metavar='MPL_FILE', type=argparse.FileType(),
        help='path of MPL file to be patched'
    )

    parser.add_argument(
        'patches', metavar='PATCH_FILE', type=argparse.FileType(), nargs='+',
        help='path of patch file to be applied to MPL file'
    )
    
    parser.add_argument(
        '-n', '--dry-run', action='store_true', default=False,
        help='report patch actions on MPL file without actually applying them')
    
    try:
        args = parser.parse_args(argv)
    except IOError as e:
        sys.stderr.write("{0.strerror}: '{0.filename}'\n".format(e))
        sys.exit(1)

    return args
        

def main(argv=None):
    args = process_args(argv)

    all_truth_tables = []
    for patch_file in args.patches:
        try:
            patch = json.load(patch_file)
        except (ValueError) as e:
            print '{0} in patch file "{1}"'.format(e, patch_file.name)
            return 1
        all_truth_tables.extend(patch['truth_tables'])
        patch_file.close()
        
    try:
        connection = sqlite3.connect(args.mpl.name)
        connection.row_factory = sqlite3.Row
        mpl_cursor = connection.cursor()

        verify_truth_tables(mpl_cursor, all_truth_tables)
        apply_truth_tables(mpl_cursor, all_truth_tables)

        if args.dry_run:
            connection.rollback()
        else:
            connection.commit()
    except MplError as e:
        print 'MPS Logic Patch Error:', e
        return 2
    finally:
        connection.close()
        args.mpl.close()

    return 0


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


