#!/usr/bin/env python
import gtk
import gtk.glade
import sys
import gobject
import gnome
import os
import gettext
import os.path

from optparse import OptionParser
from gettext import gettext as _


# Start threads subsystem
gobject.threads_init ()

bins_dir = os.path.dirname (os.path.abspath (sys.argv[0]))
prefix_dir = os.path.dirname (bins_dir)
lib_dir = os.path.join (prefix_dir, 'lib',
                        "python%d.%d" % sys.version_info[0:2],
                        'site-packages')
locale_dir = os.path.join (prefix_dir, 'share', 'locale')

# Add our default lib dir to the path
if os.path.isdir (lib_dir) and lib_dir not in sys.path:
    sys.path.append (lib_dir)

gettext.bindtextdomain("serpentine", locale_dir)
gettext.textdomain("serpentine")
gtk.glade.bindtextdomain("serpentine", locale_dir)
gtk.glade.textdomain("serpentine")


# TODO: put the window operation here
def parse_args (option, opt_str, value, parser):
    setattr (parser.values, option.dest,  list (parser.rargs))

parser = OptionParser()
parser.add_option ("-s", "--simulate", action="store_true", dest="simulate",
                   help=_("Recording operations will be done in simulation mode."),
                   default=False)
parser.add_option ("-p", "--preferences", action="store_true", dest="preferences",
                   help=_("Show preferences dialog and exit."), default = False)
                   
parser.add_option ("-w", "--write", action="callback", callback=parse_args,
                   help=_("Writes the filenames after this option to a CD. "
                   "This will show a dialog suitable for embedding in other "
                   "applications."), dest="write_files", default=None)
                   
(options, args) = parser.parse_args()

from serpentine import SerpentineApplication, SerpentineError, operations, gtkutil, validate_music_list, HeadlessApplication
import serpentine


# gtkutil.traceback_main_loop ()

class OurListener (operations.OperationListener):
    def on_finished (self, event):
        gtk.main_quit ()
        sys.exit (0)
        
listener = OurListener ()
if options.write_files:
    app = HeadlessApplication ()
else:
    app = SerpentineApplication ()

app.listeners.append (listener)
app.preferences.simulate = options.simulate
gnome_app = gnome.init ('serpentine', app.preferences.version)

if app.preferences.simulate:
    primary_text = _("Simulation mode")
    secondary_text = _("Serpentine is on simulation mode, no actual writing "
                       "will be done on inserted media.")
                       
    dlg = gtkutil.gen_warn (primary_text, secondary_text, title = "Serpentine")
    dlg.set_icon_name ("gnome-dev-cdrom-audio")
    dlg.run ()
    dlg.destroy ()
    
# Check if we want to write files
if options.write_files is not None:
    if len (options.write_files) == 0:
        print >> sys.stderr, "Choose at least one valid filename"
        sys.exit (1)
    try:
        # Check if the operation was successful
        error =  serpentine.write_files (app, options.write_files).id == operations.ERROR
        if error:
            sys.exit (1)
            
    except SerpentineError, e:
        print >> sys.stderr, e
        sys.exit (1)
    

# Show main window
else:
    if options.preferences:
        from serpentine.preferences import recordingPreferencesWindow
        win = recordingPreferencesWindow (app.preferences)
        win.set_icon_name ("gnome-dev-cdrom-audio")
        win.show ()
        win.connect ("delete-event", gtk.main_quit)
        gtk.main ()
        sys.exit (0)
        
    else:
        app.show_window ()


try:
    app.start ()
except SerpentineError, e:
    print >> sys.stderr, e
    sys.exit (1)

gtk.main()
