from fabric.operations import run, put
from fabric.api import env, task
import os

from maintenance import _get_configuration_path, load_configuration


@task
def deploy(param=None):
    param_list = ['conf', 'readmes']

    if not param:
        print "this requires input param must be one of %s" % param_list
        import sys
        sys.exit()

    if param == 'conf':
        deploy_conf()
    elif param == 'readmes':
        deploy_readmes()


@task
def backup(param=None):
    param_list = ['conf', 'meta', 'readmes']

    if not param:
        print "this requires input param must be one of %s" % param_list
        import sys
        sys.exit()

    if param == 'conf':
        _backup_conf()
    elif param == 'meta':
        _backup_meta()
    elif param == 'readmes':
        _backup_readmes()


def _backup_conf():
    configuration = env.config

    for key in configuration.templates.keys():
        section = getattr(configuration.templates, key)
        source_path = os.path.join(section['path']['local'], 'files')

        dest_path = os.path.join(
            configuration.tools.fabric.templates.conf,
            key)

        run("mkdir -p %s" % dest_path)
        put(source_path, dest_path)


def _backup_meta():
    configuration = env.config

    from fabric.operations import run, put

    source_path_layout = _get_configuration_path(
        'layout', 'development')

    config_dev = _modify_configuration('development')
    config_stg = _modify_configuration('staging')

    dest_path = configuration.tools.fabric.templates.meta

    run("mkdir -p %s" % dest_path)

    #
    # copy over the layout.yml file only

    put(source_path_layout, dest_path)

    #
    # the development.yml file needs to be
    # modified before it can be copied over

    _store_configuration(config_dev)
    _store_configuration(config_stg)


def _backup_readmes():
    configuration = env.config

    dest_readmes = configuration.tools.fabric.templates.readmes

    source_readmes = os.path.join(
        configuration.paths.project.root, 'scripts', 'readmes')

    copy_directories(source_readmes, dest_readmes)


def _modify_configuration(branch):
    """
    this method modifies a meta/branch.yml file so that it can be stored as
    a template for future branch files of the same time.

    Keyword arguments:
        branch -- the name of the branch whose configuration files we are
        modifying

    Notice that some of the values requires me to store the values with
    certain names, e.g. if the project/host is NOT 'localhost', then
    override the stored IP address with the word "PROJECT_IP"

    this method is meant to be used by _store_configuration
    """

    #
    # get the configuration dict for this branch

    config_yaml = load_configuration('config', branch)

    #
    # basic project configuration

    branch = config_yaml['project']['branch']

    config_yaml['project']['name'] = "\"PROJECT_NAME\""

    # we don't use 'paths/home' in anything other than dev
    if branch == 'development':
        config_yaml['project']['paths']['home'] = "\"PROJECT_NAME.prj\""

    config_yaml['project']['user'] = '"BRANCH_USER"'
    config_yaml['project']['group'] = '"BRANCH_GROUP"'
    config_yaml['project']['extension'] = '"BRANCH_NAME"'

    if config_yaml['project']['host'] != 'localhost':
        config_yaml['project']['host'] = '"PROJECT_IP"'

    #
    # database configuration

    config_yaml['database']['name'] = '"PROJECT_NAME_{{branch}}"'.format(
        branch=config_yaml['project']['extension'])

    if config_yaml['database']['host'] == "docker":
        config_yaml['database']['port'] = '"DOCKER_PORT"'
    else:
        config_yaml['database']['host'] = '"DATABASE_IP"'

    #
    # database user name values

    config_yaml['database']['users']['admin']['name'] = \
        '"DATABASE_ADMIN_NAME"'

    config_yaml['database']['users']['admin']['pass'] = \
        '"DATABASE_ADMIN_PASS"'

    config_yaml['database']['users']['default']['name'] = \
        '"DATABASE_USER_NAME"'

    config_yaml['database']['users']['default']['pass'] = \
        '"DATABASE_USER_PASS"'

    #
    # django configuration

    config_yaml['django']['port'] = '"DJANGO_PORT"'
    config_yaml['django']['host'] = '"DJANGO_IP"'

    #
    # nginx and virtualenv configuration

    config_yaml['nginx']['port'] = '"NGINX_PORT"'

    if hasattr(config_yaml['virtualenv'], 'name'):
        config_yaml['virtualenv']['name'] = '"PROJECT_NAME"'

    return config_yaml


def _store_configuration(config_dict):
    """
    takes config dictionary converts it to a yaml file object,
    then saves it under the appropriate file name

    Keyword arguments:
        config_dict -- yaml based configuration dictionary object
    """
    configuration = env.config

    from StringIO import StringIO
    import yaml
    from fabric.operations import put

    branch_name = config_dict['project']['branch'] + ".yml"

    dest_path = os.path.join(
        configuration.tools.fabric.templates.meta,
        branch_name)

    put(StringIO(yaml.dump(config_dict)), dest_path)


def deploy_readmes():
    """
    takes the readme files from tools/fabric/templates/readmes
    and puts then under the top level of the project/scripts directory
    """
    configuration = env.config
    source_readmes = configuration.tools.fabric.templates.readmes

    dest_readmes = os.path.join(
        configuration.paths.project.root,
        'scripts', 'readmes')

    copy_directories(source_readmes, dest_readmes)


def deploy_conf():
    """
    takes the conf templates from tools/fabric/templates/conf
    and puts them under scripts/conf.

    Note, these "conf" files are NOT the same as the meta/branch.yml conf
    files.  They are configuration files meant for the various subsystems
    of the project.  ie, database, docker, supervisor, etc.
    """
    configuration = env.config

    for key in configuration.templates.keys():
        section = getattr(configuration.templates, key)
        dest_path = section['path']['local']

        source_path = os.path.join(
            configuration.tools.fabric.templates.conf,
            key)

        build_dir = os.path.join(dest_path, 'build')
        # also create the destination 'build' directories
        # if they do not exist
        run("mkdir -p %s" % build_dir)

        copy_directories(source_path, dest_path)


def copy_directories(source_path, dest_path):
    """
    takes the files from source and copies them to dest using fabric.put

    Keyword arguments:
        source_path -- the source dir
        dest_path -- the destination dir
    """

    run("mkdir -p %s" % dest_path)

    file_list = run("ls %s" % source_path).split()
    for fname in file_list:
        fpath = os.path.join(source_path, fname)

        put(fpath, dest_path)