#!/usr/bin/env python
#
#

""" exec gozerbot commands from the command line. """

__copyright__ = 'this file is in the public domain'

# ==============
# IMPORT SECTION

# gozerbot imports

def showexceptions():
    teller = 0

    for ex in exceptionevents:
        teller += 1
        print "EXCEPTION NR %s" % teller
        print ex[1]
        print "command: "  + ex[0].txt
        print "options: " + str(ex[0].options)

    print "total of %s exceptions" % teller
    return exceptionlist

import sys, os, time
starttime = time.time()
sys.path.insert(0, os.getcwd())

from gozerbot.tests import tests
from gozerbot.utils.exception import handle_exception, exceptionlist, exceptionevents
from gozerbot.eventbase import EventBase
from gozerbot.botbase import BotBase
from gozerbot.users import users
from gozerbot.exit import globalshutdown
from gozerbot.eventhandler import mainhandler
from gozerbot.utils.log import enable_logging, disable_logging
from gozerbot.utils.generic import waitforqueue, makeoptions
from gozerbot.threads.thr import start_new_thread
from gozerbot.periodical import periodical
from gozerbot.plugins import plugins
from gozerbot.database.alchemy import startmaindb
from gozerbot.persist.persist import Persist
from gozerbot.commands import cmnds

import gozerbot

# basic imports
from optparse import OptionParser
import asyncore, time, Queue

# skip part after ##
index = 0
for i in sys.argv:
    if '//' not in i:
        index += 1
    else:
        break
    
cmndargs = sys.argv[1:index]
botargs = sys.argv[index+1:]

# END IMPORT
# ==========

parser = OptionParser(usage='usage: %prog [options]', version='%prog ' + gozerbot.__version__)
parser.add_option('-l', '--loglevel', type='string', default=False, dest='loglevel',
                  help="loglevel")
parser.add_option('-c', '--chan', type='string', default=False, dest='channel',
                  help="channel to use")
parser.add_option('-n', '--nick', type='string', default=False, dest='nick',
                  help="nick to use")
parser.add_option('-u', '--userhost', type='string', default=False, dest='userhost',
                  help="userhost to use")
parser.add_option('-e', '--exceptions', action="store_true", default=False, dest='exceptions',
                  help="show exceptions list after finishing the command")
parser.add_option('-w', '--wait', type="string", default=False, dest='wait',
                  help="nr of seconds to wait for completion")
parser.add_option('-v', '--verbose', action="store_true", default=False, dest='verbose',
                  help="be verbose")
parser.add_option('-x', '--loop', type="string", default=False, dest='loop',
                  help="nr times to loop")
parser.add_option('-b', '--bork', action='store_true', default=False,dest='bork', 
                  help="bork (exit) on exception")

opts, args = parser.parse_args(cmndargs)
opts.args = args

v = opts.verbose

try:
    cmnd = args[0]
except IndexError:
    print "what command?"
    os._exit(0)

if opts.bork:
    import gozerbot.utils.exception
    gozerbot.utils.exception.borkonexception = True
    print "BORK ON EXCEPTION ENABLED"

enable_logging(int(opts.loglevel) or 1000)
periodical.start()
startmaindb()

print "GOZERBOT %s starting" % gozerbot.__version__
print "loading plugins ..."
plugins.regplugins()
plugins.enableall()
plugins.regplugins()

print "done"
queue = Queue.Queue()
end = False

try:
    bot = BotBase('execbot', {'nick': opts.nick or 'exec'})
    event = EventBase()
    event.nick = opts.nick or 'exec'
    event.userhost = opts.userhost or 'exec@gozerbot'

    try:
        users.add(event.nick, [event.userhost,], ['USER', 'OPER'])
    except Exception, ex:
        pass

    event.txt = "!" + " ".join(args)

    if botargs:
         event.txt += ' ' + ' '.join(botargs)

    event.origtxt = event.txt
    event.bot = bot
    event.msg = True
    event.isdcc = True
    event.channel = opts.channel or "exec@gozerbot"
    event.queues.append(Queue.Queue())
    makeoptions(event)
    
    # GO !

    start_new_thread(bot.serveforever, ())

    if opts.loop:
        loop = int(opts.loop)
    else:
        loop = 1
    for i in range(loop):
        print "STARTING LOOP #%s" % i
        start_new_thread(bot.domsg, (event, ))

    if opts.wait:
        resultnotused = waitforqueue(queue, timeout=int(opts.wait))
    else:
        resultnotused = waitforqueue(queue, 3600)

    if opts.exceptions:
        showexceptions()

    if v: print "elapsed time: %s seconds" % (time.time() - starttime)
    sys.stdout.flush()
    time.sleep(0.01)
    os._exit(0)

except KeyboardInterrupt:
    showexceptions()
except Exception, ex:
    handle_exception()
    disable_logging()
    showexceptions()
    sys.stdout.flush()
    time.sleep(0.01)
    os._exit(1)

teller = 0
for where, test in tests.err.iteritems():
    teller += 1
    print "ERROR %s: %s" % (teller, test)

teller = 0
for toolate, sec in tests.toolate.iteritems():
    teller += 1
    print "TOOLATE %s: %s (%s)" % (teller, toolate, sec)

