#!/usr/bin/env python
__requires__="TurboGears"

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

from turbogears import config

from transifex.util import header, load_config
from transifex.model import *

from turbogears.database import metadata, session
from turbogears.database import bind_meta_data

log = logging.getLogger(__name__)

tx_tables = [users_table, repository_table, module_table, branch_table, action_log_table, branch_module_table]

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...")
    
    #metadata.drop_all(tables=tx_tables)
    metadata.drop_all()
    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...")
    #metadata.create_all(tables=tx_tables)
    metadata.create_all()
    log.info("Done.\n")


def import_branches():
    """
    Import basic branches in the database
    """
    
    log.info("Initializing Branches table...")
    items = ({'name': u'HEAD'},
             {'name': u'trunk'},
             {'name': u'tip'},
             {'name': u'0.2'},
             {'name': u'master'},
            )
    for item in items:
        additem = Branch(name=item['name'])
        session.save(additem)
        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=u'guest',
             display_name=u'Guesty Guest',
             email_address=u'guest@example.com',
             password=u'guest')
    session.save(u)
    log.info(' - %s' % (u.user_name))
    try:
        g=Group(group_name=u'cvsl10n', display_name=u'Translators')
        g.users.append(u)
        session.save(g)
        log.info(' - %s' % (g.display_name))
    except Exception, e:
        log.debug(e)
    
    u = User(user_name=u'admin',
             display_name=u'Adminy Administrator',
             email_address=u'admin@example.com',
             password=u'admin')
    session.save(u)
    log.info(' - %s' % (u.user_name))
    try:
        g=Group(group_name=u'l10n-admin', display_name=u'Administrators')
        g.users.append(u)
        session.save(g)
        log.info(' - %s' % (g.display_name))
    except Exception, e:
        log.debug(e)

    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://code.transifex.org/transifex",
                 "%s/hgroot/transifex" % troot])
    coms_set.append(coms)
    #git
    coms = []
    coms.append(["mkdir", "-p", "%s/gitroot" % troot])
    coms.append(["git", "clone", "git://git.fedorahosted.org/git/system-config-boot",
                 "%s/gitroot/system-config-boot" % 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': u'testrepo-cvs',
              'type': u'cvs',
              'root': u'%s/cvsroot' % troot,
             },
             {'name': u'testrepo-svn',
              'type': u'svn',
              'root': u'file://%s/svnroot' % troot,
             },
             {'name': u'testrepo-hg',
              'type': u'hg',
              'root': u'%s/hgroot' % troot,
             },
             {'name': u'testrepo-git',
              'type': u'git',
              'root': u'%s/gitroot' % troot,
             },
            )
    for item in items:
        additem = Repository(name=item['name'],
                             root=item['root'],
                             type=item['type'])
        session.save(additem)
        log.info(' - %s' % (additem))
    session.flush() # needed by import_test_modules() to ensure we can select the repo
    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': u'testmodule-cvs',
              'repository': u'testrepo-cvs',
              'scmmodule': u'transifex',
              'filefilter': u'',
              'directory': u'',
              'changelog': u'',
              'branches': [u'HEAD'],
             },
             {'name': u'testmodule-svn',
              'repository': u'testrepo-svn',
              'scmmodule': u'transifex',
              'filefilter': u'',
              'directory': u'',
              'changelog': u'',
              'branches': [u'trunk'],
             },
             {'name': u'testmodule-hg-transifex',
              'repository': u'testrepo-hg',
              'scmmodule': u'transifex',
              'filefilter': u'.*/po/.*',
              'directory': u'',
              'changelog': u'',
              'branches': [u'tip', u'0.2'],
             },
             {'name': u'testmodule-git',
              'repository': u'testrepo-git',
              'scmmodule': u'system-config-boot',
              'filefilter': u'.*/po/.*',
              'directory': u'',
              'changelog': u'',
              'branches': [u'master'],
             },
            )
    for item in items:
        additem = Module(name=item['name'],
                         repository=Repository.byName(item['repository']),
                         scmmodule=item['scmmodule'],
                         filefilter=item['filefilter'],
                         changelog=item['changelog'],
                         directory=item['directory'])
        log.info(' - %s' % (additem))
        for branch in item['branches']:
            addBranch = additem.branches.append(Branch.query.filter_by(name=branch).one())
            log.info('   - %s' % (branch))
        session.save(additem)
    log.info("Done.\n")

def main():

    parser = OptionParser(epilog="Transifex initialization tool."
        + " Initializes the database and configures"
        + " some test modules to play around with.")

    parser.add_option('-f', '--force', action='store_true', dest='force',
        help="Non-interactive, don't prompt for confirmation")
    parser.add_option('-v', '--verbose', action='store_true', dest='verbose',
        help="Be verbose!")
    parser.add_option('-t', '--test', action='store_true', dest='test',
        help="Create some local testing repos to play around with")
    parser.add_option('-c', '--config', dest='config',
        help="Specify turbogears config file (e.x. dev.cfg)")

    (options, args) = parser.parse_args()

    if options.verbose:
        log.setLevel(logging.WARNING)

    load_config(options.config)

    bind_meta_data()
   
    print header("Transifex initialization")
    if not options.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()
    session.begin()
    clean_tables()
    create_tables()
    session.flush()
    if options.test:
        import_branches()
        import_users()
        create_test_repos()
        import_test_repos()
        import_test_modules()
    session.commit()
    print "\nAll done.\n"


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