#!/usr/bin/env python
"""
Pique.
"""
import pique
import sys
import argparse
import numpy
from Tkinter import *
from tkFileDialog import *


# entry point functions for mode commands

def batch( args ) :
    """
    entry point for batch mode
    """
    pique.runtime.detect(   args.name,
                            args.ipfile,
                            args.bgfile,
                            args.mapfile,
                            args.alpha,
                            args.l_thresh,
                            args.pickle_file )

def mainTk( args ) :
    """
    entry point for Tk interface
    """
    root = Tk()
    app = PiqueApp( root )
    root.mainloop()

def test( args ) :
    """
    entry point for test mode
    """
    pique.runtime.detect(   'test',
                            pique.constants.test_ip_file,
                            pique.constants.test_bg_file,
                            pique.constants.test_map_file,
                            30,
                            300,
                            True )

def mapmaker( args ) :
    """
    entry point for mapmaker utility
    """
    pique.runtime.makemap(  args.name,
                            args.bamfile,
                            args.window,
                            args.stride,
                            args.highest,
                            args.lowest,
                            args.bins )

# the main argument parser
parser = argparse.ArgumentParser( 
                            description = 'Pique, a ChIP-seq analytical tool.',
                            prog        = 'pique' )

subparsers = parser.add_subparsers( help= '',
                            title       = 'commands' )

# batch mode options
parser_batch = subparsers.add_parser( 'batch', help='command-line mode for peak detection' )

parser_batch.set_defaults( func=batch )

parser_batch.add_argument(  '-name', 
                            action      = 'store', 
                            dest        = 'name', 
                            required    = True,
                            help        = 'project name' )

parser_batch.add_argument(  '-ip', 
                            action      = 'store', 
                            dest        = 'ipfile', 
                            required    = True,
                            help        = 'BAM file for IP data' )

parser_batch.add_argument(  '-bg',
                            action      = 'store',
                            dest        = 'bgfile',
                            required    = True,
                            help        = 'BAM file for control data' )

parser_batch.add_argument(  '-map',
                            action      = 'store',
                            dest        = 'mapfile',
                            required    = True,
                            help        = 'genome map file' )

parser_batch.add_argument(  '-a', 
                            action      = 'store',
                            dest        = 'alpha',
                            default     = 30,
                            type        = int,
                            help        = 'read length' )

parser_batch.add_argument(  '-l',
                            action      = 'store',
                            dest        = 'l_thresh',
                            default     = 300,
                            type        = int,
                            help        = 'expected binding footprint' )

parser_batch.add_argument(  '-p', 
                            action      = 'store_true', 
                            dest        = 'pickle_file',
                            default     = False, 
                            required    = False, 
                            help        = 'make a pickel file' )

# Tk mode
parser_tk = subparsers.add_parser( 'tk', help='GUI mode for peak detection' )
parser_tk.set_defaults( func=mainTk )

# test mode
parser_tk = subparsers.add_parser( 'test', help='testing mode, downloads online test data' )
parser_tk.set_defaults( func=test )

# mapmaker mode
parser_map = subparsers.add_parser( 'mapmaker', help='genome analysis region mapping utility' )
parser_map.set_defaults( func=mapmaker )

parser_map.add_argument(  '-name', 
                            action      = 'store', 
                            dest        = 'name', 
                            required    = True,
                            help        = 'project name' )

parser_map.add_argument(   '-bamfile', 
                            action      = 'store', 
                            dest        = 'bamfile', 
                            required    = True,
                            help        = 'BAM file of aligned data' )

parser_map.add_argument(   '-window',
                            action      = 'store',
                            dest        = 'window',
                            default     = 50000,
                            type        = int,
                            help        = 'sliding window size' )

parser_map.add_argument(   '-stride',
                            action      = 'store',
                            dest        = 'stride',
                            default     = 200,
                            type        = int,
                            help        = 'stride length' )

parser_map.add_argument(   '-highest',
                            action      = 'store',
                            dest        = 'highest',
                            required    = True,
                            type        = int,
                            help        = 'highest histogram bin' )

parser_map.add_argument(   '-lowest',
                            action      = 'store',
                            dest        = 'lowest',
                            required    = True,
                            type        = int,
                            help        = 'lowest histogram bin' )

parser_map.add_argument(   '-bins',
                            action      = 'store',
                            dest        = 'bins',
                            default     = 64,
                            type        = int,
                            help        = 'number of histogram bins' )



class PiqueApp :
    def __init__( self, master ) :
        self.IPfile  = None
        self.BGfile  = None
        self.mapfile = None
        self.alpha   = 300
        self.l_thresh= 30
        self.name    = 'MyProject'
        self.master = master

        master.title( 'Pique ' + str( pique.version() ) )
        
        # project name
        frame0 = Frame( master )
        self.nametext     = Entry(  frame0                  )
        self.nametext.pack( side=LEFT )
        self.nametext.insert( 0, self.name )
        
        self.namelabel = Label( frame0, text='Project name' )
        self.namelabel.pack( side=RIGHT, fill=X )
        frame0.pack( fill=X )

        # IP file 
        frame1 = Frame( master )
        self.IPfilebutton = Button( frame1,                 \
                                    text='IP Track',        \
                                    command=self.setIPfile  )
        self.IPfilebutton.pack( side=RIGHT, fill=X )
        
        self.IPfiletext  = Entry(   frame1                  )
        self.IPfiletext.pack( side=LEFT )
        frame1.pack( fill=X )
         
        # BG file 
        frame2 = Frame( master )
        self.BGfilebutton = Button( frame2,                 \
                                    text='BG Track',        \
                                    command=self.setBGfile  )
        self.BGfilebutton.pack( side=RIGHT, fill=X )
        
        self.BGfiletext  = Entry(   frame2                  )
        self.BGfiletext.pack( side=LEFT )
        frame2.pack( fill=X )
        
        # map file
        frame3 = Frame( master )
        self.mapfilebutton = Button(frame3,                 \
                                    text='Map (optional)',  \
                                    command=self.setmapfile )
        self.mapfilebutton.pack( side=RIGHT, fill=X )
        
        self.mapfiletext  = Entry(  frame3                  )
        self.mapfiletext.pack( side=LEFT )
        frame3.pack( fill=X )
        
        # alpha
        frame4 = Frame( master )
        self.alphatext    = Entry(  frame4                  )
        self.alphatext.pack( side=LEFT )
        self.alphatext.insert( 0, self.alpha )        
        
        self.alphalabel = Label( frame4, text='Fragment length' )
        self.alphalabel.pack( side=RIGHT )
        frame4.pack( fill=X )       
        
        # l_thresh
        frame5 = Frame( master )
        self.lthreshtext  = Entry(  frame5                  )
        self.lthreshtext.pack( side=LEFT )
        self.lthreshtext.insert( 0, self.l_thresh )        
        
        self.lthreshlabel = Label( frame5, text='Read length' )
        self.lthreshlabel.pack( side=RIGHT )
        frame5.pack( fill=X )
        
        # control buttons
        frame6 = Frame( master )
        self.runbutton    = Button( frame6,                 \
                                    text='Run',             \
                                    command=self.run        )
        self.runbutton.pack( side=RIGHT )
        
        self.quitbutton   = Button( frame6,                 \
                                    text='Quit',            \
                                    command=master.quit     )
        self.quitbutton.pack( side=LEFT )
        frame6.pack( fill=X )
        
    def setIPfile( self ) :
        self.IPfile = askopenfilename()
        l = len(self.IPfiletext.get())
        self.IPfiletext.delete( 0, l )
        self.IPfiletext.insert( 0, self.IPfile )
        print 'IP file : ' + self.IPfile
        
    def setBGfile( self ) :
        self.BGfile = askopenfilename()
        l = len(self.BGfiletext.get())
        self.BGfiletext.delete( 0, l )
        self.BGfiletext.insert( 0, self.BGfile )
        print 'BG file : ' + self.BGfile
        
    def setmapfile( self ) :
        self.mapfile = askopenfilename()
        l = len(self.mapfiletext.get())
        self.mapfiletext.delete( 0, l )
        self.mapfiletext.insert( 0, self.mapfile )
        print 'map file : ' + self.mapfile
        
    def run( self ) :
        # check inputs...
        name     = self.nametext.get().strip()
        
        # set logfile
        logfile = name + '.log'
        
        alpha    = int( self.alphatext.get().strip() )
        l_thresh = int( self.lthreshtext.get().strip() )
        
        IPfile   = self.IPfile
        BGfile   = self.BGfile
        mapfile  = self.mapfile

        # pickle file
        pickle_file = name + '.pickle'
        
        pique.runtime.detect( name, IPfile, BGfile, mapfile, alpha, l_thresh, pickle_file )
        self.master.quit()

args = parser.parse_args()
args.func(args)
