#!/usr/bin/env python

import sys
import os
import subprocess
import string
import sqlite3

from . import mpsconfigquery


def export(dbfile, path, verbose):
    """Write csv files to the folder specified by path"""

    if verbose:
        print "Exporting CSV files to directory", path
    
    extension = '.csv'
    tables = (
                { 'name'    : 'Link Processor Table',
                  'path'    : os.path.join(path, 'LinkProcessor{0}'.format(extension)),
                  'outfile' : None,
                  'query'   : """select
                                    fault_number,
                                    is_autorecoverable,
                                    
                                    device_name,
                                    fault_name,
                                    fault_id,
                                    pv_device_type,
                                    pv_area,
                                    pv_position,
                                    pv_attribute,
                                    ok_state_name,
                                    faulted_state_name,
                                    position_x,
                                    position_y,
                                    position_z,
                                    description,
                                    area
                                from link_processor_fault
                                order by device_name, fault_name;"""
                },
                { 'name'    : 'Link Node Table',
                  'path'    : os.path.join(path, 'LinkNode{0}'.format(extension)),
                  'outfile' : None,
                  'query'   : """select
                                    fault_number,
                                    is_autorecoverable,
                                    link_node_id,
                                    link_node_type_enum,
                                    fault_id,

                                    device_name,
                                    fault_name,
                                    pv_device_type,
                                    pv_area,
                                    pv_position,
                                    pv_attribute,
                                    ok_state_name,
                                    faulted_state_name,
                                    link_node_type_name,
                                    description,
                                    area
                                from link_node_fault
                                order by link_node_id, device_name, fault_name;"""
                },
                { 'name'    : 'Link Node Channel Configuration Table',
                  'path'    : os.path.join(path, 'LinkNodeChannel{0}'.format(extension)),
                  'outfile' : None,
                  'query'   : """select
                                    fault_number,

                                    link_node_id,
                                    card,
                                    channel,
                                    is_autorecoverable,
                                    is_deadman,
                                    debounce_enum,
                                    debounce_time,

                                    device_name,
                                    fault_name,
                                    fault_id,
                                    pv_device_type,
                                    pv_area,
                                    pv_position,
                                    pv_attribute,
                                    ok_state_name,
                                    faulted_state_name,
                                    debounce_name,
                                    position_x,
                                    position_y,
                                    position_z,
                                    cable,
                                    description,
                                    area
                                from link_node_channel_fault
                                order by link_node_id, card, channel;"""
                },
                { 'name'    : 'EPICS Fault Configuration Table',
                  'path'    : os.path.join(path, 'EpicsFault{0}'.format(extension)),
                  'outfile' : None,
                  'query'   : """select
                                    fault_number,
                                    is_autorecoverable,

                                    input_pv,

                                    device_name,
                                    fault_name,

                                    fault_id,
                                    pv_device_type,
                                    pv_area,
                                    pv_position,
                                    pv_attribute,
                                    ok_state_name,
                                    faulted_state_name,
                                    position_x,
                                    position_y,
                                    position_z,
                                    description,
                                    area
                                from epics_fault
                                order by fault_number;"""
                },
             )
    
    
    # See if all output files are writable
    for table in tables:
        try:
            table['outfile'] = open(table['path'], 'w')
        except IOError, e:
            sys.stderr.write('Could not open "%s": %s\n' % (table['path'], e.strerror))
            return 1
    
    
    for table in tables:
        if verbose:
            print "Exporting CSV file:", table['name'], "to", table['path']
       
        outfile = table['outfile']
        outfile.write('# ')
        outfile.flush()

        p = subprocess.Popen(('sqlite3', dbfile), stdin=subprocess.PIPE, stdout=outfile)
        p.stdin.write('.mode csv\n')
        p.stdin.write('.headers on\n')
        p.stdin.write(table['query'])
        p.stdin.close()        
        p.wait()
        
        outfile.close()


