#!/usr/bin/env python

import sys
import shutil
import logging
from os import path, mkdir

from sqlobject import SQLObjectNotFound
from turbogears.database import PackageHub
from turbogears import config

from transifex.util import header, load_config
from transifex.model import Branch, Repository, Module, ActionLog

hub = PackageHub("transifex")
__connection__ = hub

log = logging.getLogger(__name__)

def get_testing_dir():
    return path.join(config.get("workdir"), "testing-repos")


def init_dirs():
    """
    Create some necessary dirs for the app
    """
    
    dirs = ["workdir", "scratchdir"]
    for dir in dirs:
        dirpath = config.get(dir)
        if not path.exists(dirpath):
            mkdir(dirpath)
        else:
            print "Dir %s exists, skipping." % dir
    
def clean_tables():
    """
    Drop some tables from the DB
    """
    from transifex.model import Branch, Repository, Module, ActionLog, User

    log.info("Cleaning out tables...")
    Repository.dropTable(ifExists=True, cascade=True)
    Branch.dropTable(ifExists=True, cascade=True)
    Module.dropTable(ifExists=True, cascade=True)
    ActionLog.dropTable(ifExists=True, cascade=True)
    User.dropTable(ifExists=True, cascade=True)
    log.info("Done.\n")


def create_tables():
    """
    Create some tables from the DB
    """
    from transifex.model import Branch, Repository, Module, ActionLog, User

    log.info("Creating tables...")
    Repository.createTable(ifNotExists=True)
    Branch.createTable(ifNotExists=True)
    Module.createTable(ifNotExists=True)
    ActionLog.createTable(ifNotExists=True)
    User.createTable(ifNotExists=True)
    log.info("Done.\n")


def import_branches():
    """
    Import basic branches in the database
    """
    from transifex.model import Branch
    
    log.info("Initializing Branches table...")
    items = ({'name': 'HEAD'},
             {'name': 'trunk'},
             {'name': 'tip'},
             {'name': '0.9.3'},
             {'name': 'master'},
            )
    for item in items:
        additem = Branch(name=item['name'])
        log.info(' - %s' % (additem))
    log.info("Done.\n")


def import_users():
    """
    Import basic users in the database
    """
    from transifex.model import User, Group
    
    log.info("Initializing Users table...")
    
    u = User(user_name='guest',
             display_name='Guesty Guest',
             email_address='guest@example.com',
             password='guest')
    log.info(' - %s' % (u.user_name))
    try:
        g=Group(group_name='cvsl10n', display_name='Translators')
        g.addUser(u)
        log.info(' - %s' % (g.display_name))
    except:
        pass
    
    u = User(user_name='admin',
             display_name='Adminy Administrator',
             email_address='admin@example.com',
             password='admin')
    log.info(' - %s' % (u.user_name))
    try:
        g=Group(group_name='l10n-admin', display_name='Administrators')
        g.addUser(u)
        log.info(' - %s' % (g.display_name))
    except:
        pass;

    log.info("Done.\n")
    

def create_test_repos():
    """
    Create test repositories in <workdir>/testing-repos
    """
    from transifex.util import run_commands
    troot = get_testing_dir()
    log.info("Creating Testing repositories...")
    sets = ["init", "cvs", "svn", "hg", "git"]
    coms_set =[]
    #init
    coms = []
    coms.append(["rm", "-rf", troot])
    coms_set.append(coms)
    #cvs
    coms = []
    coms.append(["mkdir", "-p", "%s/cvsroot" % troot])
    coms.append(["cvs", "-d", "%s/cvsroot" % troot, "init"])
    coms.append(["cvs", "-d", "%s/cvsroot" % troot, "import", "-I'.hg*'",
                 "-m'imported'", "transifex", "yoyo", "start"])
    coms_set.append(coms)
    #svn
    coms = []
    coms.append(["svnadmin", "create", "%s/svnroot" % troot])
    coms.append(["svn", "import", "-m'imported'", ".",
                 "file://%s/svnroot/transifex/trunk" % troot])
    coms.append(["svn", "import", "-m'imported'", ".",
                 "file://%s/svnroot/transifex/branches/foo" % troot])
    coms_set.append(coms)
    #hg
    coms = []
    coms.append(["mkdir", "-p", "%s/hgroot" % troot])
    coms.append(["hg", "clone", "http://hg.fedorahosted.org/hg/smolt",
                 "%s/hgroot/smolt" % troot])
    coms_set.append(coms)
    #git
    coms = []
    coms.append(["mkdir", "-p", "%s/gitroot" % troot])
    coms.append(["git", "clone", "git://git.fedorahosted.org/git/revisor",
                 "%s/gitroot/revisor" % troot])
    coms_set.append(coms)

    for (i, scmtype) in enumerate(sets):
        log.info(' - %s' % scmtype)
        run_commands(coms_set[i])
    log.info("Done.\n")


def import_test_repos():
    """
    Import testing repositories in the database
    """
    from transifex.model import Repository
    
    troot = get_testing_dir()
    log.info("Initializing Testing repositories...")
    items = ({'name': 'testrepo-cvs',
              'type': 'cvs',
              'root': '%s/cvsroot' % troot,
             },
             {'name': 'testrepo-svn',
              'type': 'svn',
              'root': 'file://%s/svnroot' % troot,
             },
             {'name': 'testrepo-hg',
              'type': 'hg',
              'root': '%s/hgroot' % troot,
             },
             {'name': 'testrepo-git',
              'type': 'git',
              'root': '%s/gitroot' % troot,
             },
            )
    for item in items:
        additem = Repository(name=item['name'],
                             root=item['root'],
                             type=item['type'])
        log.info(' - %s' % (additem))
    log.info("Done.\n")


def import_test_modules():
    """
    Import testing modules in the database
    """
    from transifex.model import Module, Branch, Repository
    
    log.info("Initializing Testing modules...")
    items = ({'name': 'testmodule-cvs',
              'repository': 'testrepo-cvs',
              'scmmodule': 'transifex',
              'filefilter': '',
              'directory': '',
              'changelog': '',
              'branches': ['HEAD'],
             },
             {'name': 'testmodule-svn',
              'repository': 'testrepo-svn',
              'scmmodule': 'transifex',
              'filefilter': '',
              'directory': '',
              'changelog': '',
              'branches': ['trunk'],
             },
             {'name': 'testmodule-hg-smolt',
              'repository': 'testrepo-hg',
              'scmmodule': 'smolt',
              'filefilter': '.*/po/.*',
              'directory': 'client',
              'changelog': '',
              'branches': ['tip', '0.9.3'],
             },
             {'name': 'testmodule-git-revisor',
              'repository': 'testrepo-git',
              'scmmodule': 'revisor',
              'filefilter': '.*/po/.*',
              'directory': '',
              'changelog': 'ChangeLog',
              'branches': ['master'],
             },
            )
    for item in items:
        additem = Module(name=item['name'],
                         repository=Repository.selectBy(
                            name=item['repository'])[0],
                         scmmodule=item['scmmodule'],
                         filefilter=item['filefilter'],
                         changelog=item['changelog'],
                         directory=item['directory'])
        log.info(' - %s' % (additem))
        for branch in item['branches']:
            addBranch = additem.addBranch(Branch.selectBy(name=branch)[0])
            log.info('   - %s' % (branch))
    log.info("Done.\n")


def usage(name):
    print '''Transifex initialization tool. Inits the database and configures
some test modules to play around with.

Usage:
  %(name)s [OPTIONS...]

Options:
  -f, --force\t\tNon-interactive, don't prompt for confirmation
  -h, --help\t\tPrint this help message and exit
  -t, --test\t\tCreate some local testing repos to play around with
''' % {'name': name}
#  -v, --verbose\t\tIncrease verbosity


def main():
    import getopt
    
    try:
        opts, args = getopt.getopt(sys.argv[1:],
                                   "fhtv",
                                   ["force", "help",
                                    "test", "verbose"])
    except getopt.GetoptError:
        # print help information and exit:
        usage(sys.argv[0])
        sys.exit(2)
    configfile = None
    force = False
    test = False
    verbose = False
    for o, a in opts:
        if o in ("-h", "--help"):
            usage(sys.argv[0])
            sys.exit(2)
        if o in ("-f", "--force"):
            force = True
        if o in ("-t", "--test"):
            test = True
#        if o in ("-v", "--verbose"):
#            verbose  = True

    #FIXME: Doesn't really work.
    if not verbose:
        log.setLevel(logging.WARNING)
    
    load_config(configfile)
    print header("Transifex initialization")
    if not force:
        print """
WARNING: Any existing Transifex database will be DELETED.

This script will initialize your database and create some sample
modules in '%(troot)s',
which you can use to play around with and simply delete them afterwards.
If this is the first time you are running Transifex, this is
probably what you want.""" % {'troot': get_testing_dir()}
        confirm = raw_input("""
Are you sure you want to continue and empty any existing
transifex database you might have? [y/N] """)
        if confirm != 'y':
            print "Aborted.\n"
            return 0
    init_dirs()
    hub.begin()
    clean_tables()
    hub.commit()
    create_tables()
    if test:
        import_branches()
        import_users()
        create_test_repos()
        import_test_repos()
        import_test_modules()
    hub.commit()
    print "\nAll done.\n"

if __name__ == "__main__":
    sys.exit(main())