#!/usr/bin/env python

""" Populate the pagure db with some dev data. """

import argparse

import os

import sys

from sqlalchemy import create_engine, MetaData

import pagure

import pagure.flask_app

import tests

'''

Usage:

python dev-data.py --init

python dev-data.py --clean

python dev-data.py --populate

python dev-data.py --all

'''

_config = pagure.config.config.reload_config()

def init_database():

    DB_URL = _config['DB_URL']

    # create the table if it doesnt exist

    pagure.lib.model.create_tables(

        DB_URL,

        _config.get('PATH_ALEMBIC_INI', None),

        acls=_config.get('ACLS', {}),

        debug=True)

    engine = create_engine('%s' % DB_URL, echo=True)

    metadata = MetaData(engine)

    metadata.reflect(bind=engine)

    return engine, metadata

def empty_dev_db(metadata, engine):

    print('')

    print('')

    print('WARNING: Deleting all data from ', _config['DB_URL'])

    # Dangerous: this will wipe the data from the table but keep the schema

    print('')

    response = raw_input('Do you want to continue yes or no?    ')

    if 'yes'.startswith(response.lower()):

        for tbl in reversed(metadata.sorted_tables):

            if tbl.fullname != 'acls':

                engine.execute(tbl.delete())

def insert_data(session, username, user_email):

    _config['EMAIL_SEND'] = False

    _config['TESTING'] = True

    ######################################

    # tags

    item = pagure.lib.model.Tag(

        tag='tag1',

    )

    session.add(item)

    session.commit()

    ######################################

    # Users

    # Create a couple of users

    item = pagure.lib.model.User(

        user='pingou',

        fullname='PY C',

        password='foo',

        default_email='bar@pingou.com',

    )

    session.add(item)

    session.commit()

    item = pagure.lib.model.User(

        user='foo',

        fullname='foo bar',

        password='foo',

        default_email='foo@bar.com',

    )

    session.add(item)

    session.commit()

    item = pagure.lib.model.User(

        user=username,

        fullname=username,

        password='foo',

        default_email=user_email,

    )

    session.add(item)

    session.commit()

    ######################################

    # pagure_group

    item = pagure.lib.model.PagureGroup(

        group_name='admin',

        user_id=1,

        display_name='admin',

        description='Admin Group',

    )

    session.add(item)

    session.commit()

    # Add a couple of groups so that we can list them

    item = pagure.lib.model.PagureGroup(

        group_name='group',

        group_type='user',

        user_id=1,  # pingou

        display_name='group group',

        description='this is a group group',

    )

    session.add(item)

    session.commit()

    item = pagure.lib.model.PagureGroup(

        group_name='rel-eng',

        group_type='user',

        user_id=1,  # pingou

        display_name='Release Engineering',

        description='The group of release engineers',

    )

    session.add(item)

    session.commit()

    ######################################

    # projects

    import shutil

    # delete folder from local instance to start from a clean slate

    if os.path.exists(pagure.APP.config['GIT_FOLDER']):

        shutil.rmtree(_config['GIT_FOLDER'])

    tests.create_projects(session)

    tests.create_projects_git(_config['GIT_FOLDER'], bare=True)

    tests.add_content_git_repo(

        os.path.join(_config['GIT_FOLDER'], 'test.git'))

    tests.add_readme_git_repo(

        os.path.join(_config['GIT_FOLDER'], 'test.git'))

    # Add some content to the git repo

    tests.add_content_git_repo(

        os.path.join(_config['GIT_FOLDER'], 'forks', 'pingou',

                     'test.git'))

    tests.add_readme_git_repo(

        os.path.join(_config['GIT_FOLDER'], 'forks', 'pingou',

                     'test.git'))

    tests.add_commit_git_repo(

        os.path.join(_config['GIT_FOLDER'], 'forks', 'pingou',

                     'test.git'), ncommits=10)

    ######################################

    # user_emails

    item = pagure.lib.model.UserEmail(

        user_id=1,

        email='bar@pingou.com')

    session.add(item)

    item = pagure.lib.model.UserEmail(

        user_id=1,

        email='foo@pingou.com')

    session.add(item)

    item = pagure.lib.model.UserEmail(

        user_id=2,

        email='foo@bar.com')

    session.add(item)

    item = pagure.lib.model.UserEmail(

        user_id=3,

        email=user_email)

    session.add(item)

    session.commit()

    ######################################

    # user_emails_pending

    user = pagure.lib.search_user(session, username='pingou')

    email_pend = pagure.lib.model.UserEmailPending(

        user_id=user.id,

        email='foo@fp.o',

        token='abcdef',

    )

    session.add(email_pend)

    session.commit()

    ######################################

    # issues

    # Add an issue and tag it so that we can list them

    item = pagure.lib.model.Issue(

        id=1,

        uid='foobar',

        project_id=1,

        title='Problem with jenkins build',

        content='For some reason the tests fail at line:24',

        user_id=1,  # pingou

    )

    session.add(item)

    session.commit()

    item = pagure.lib.model.Issue(

        id=2,

        uid='foobar2',

        project_id=1,

        title='Unit tests failing',

        content='Need to fix code for the unit tests to '

                'pass so jenkins build can complete.',

        user_id=1,  # pingou

    )

    session.add(item)

    session.commit()

    user = pagure.lib.search_user(session, username=username)

    item = pagure.lib.model.Issue(

        id=3,

        uid='foobar3',

        project_id=1,

        title='Segfault during execution',

        content='Index out of bounds for variable i?',

        user_id=user.id,  # current user

    )

    session.add(item)

    session.commit()

    ######################################

    # pagure_user_group

    group = pagure.lib.search_groups(session, pattern=None,

                                     group_name="rel-eng", group_type=None)

    user = pagure.lib.search_user(session, username='pingou')

    item = pagure.lib.model.PagureUserGroup(

        user_id=user.id,

        group_id=group.id

    )

    session.add(item)

    session.commit()

    user = pagure.lib.search_user(session, username=username)

    group = pagure.lib.search_groups(session, pattern=None,

                                     group_name="admin", group_type=None)

    item = pagure.lib.model.PagureUserGroup(

        user_id=user.id,

        group_id=group.id

    )

    session.add(item)

    session.commit()

    user = pagure.lib.search_user(session, username='foo')

    group = pagure.lib.search_groups(session, pattern=None,

                                     group_name="group", group_type=None)

    item = pagure.lib.model.PagureUserGroup(

        user_id=user.id,

        group_id=group.id

    )

    session.add(item)

    session.commit()

    ######################################

    # projects_groups

    group = pagure.lib.search_groups(session, pattern=None,

                                     group_name="rel-eng", group_type=None)

    repo = pagure.lib.get_authorized_project(session, 'test')

    item = pagure.lib.model.ProjectGroup(

        project_id=repo.id,

        group_id=group.id

    )

    session.add(item)

    session.commit()

    group = pagure.lib.search_groups(session, pattern=None,

                                     group_name="admin", group_type=None)

    repo = pagure.lib.get_authorized_project(session, 'test2')

    item = pagure.lib.model.ProjectGroup(

        project_id=repo.id,

        group_id=group.id

    )

    session.add(item)

    session.commit()

    ######################################

    # pull_requests

    repo = pagure.lib.get_authorized_project(session, 'test')

    forked_repo = pagure.lib.get_authorized_project(session, 'test')

    req = pagure.lib.new_pull_request(

        session=session,

        repo_from=forked_repo,

        branch_from='master',

        repo_to=repo,

        branch_to='master',

        title='Fixing code for unittest',

        user=username,

        requestfolder=None,

    )

    session.commit()

    ######################################

    # tokens

    tests.create_tokens(session)

    ######################################

    # user_projects

    user = pagure.lib.search_user(session, username='foo')

    repo = pagure.lib.get_authorized_project(session, 'test')

    item = pagure.lib.model.ProjectUser(

        project_id=repo.id,

        user_id=user.id

    )

    session.add(item)

    session.commit()

    user = pagure.lib.search_user(session, username=username)

    repo = pagure.lib.get_authorized_project(session, 'test2')

    item = pagure.lib.model.ProjectUser(

        project_id=repo.id,

        user_id=user.id

    )

    session.add(item)

    session.commit()

    ######################################

    # issue_comments

    item = pagure.lib.model.IssueComment(

        user_id=1,

        issue_uid='foobar',

        comment='We may need to adjust the unittests instead of the code.',

    )

    session.add(item)

    session.commit()

    ######################################

    # issue_to_issue

    repo = pagure.lib.get_authorized_project(session, 'test')

    all_issues = pagure.lib.search_issues(session, repo)

    pagure.lib.add_issue_dependency(session, all_issues[0],

                                    all_issues[1], 'pingou',

                                    _config['GIT_FOLDER'])

    ######################################

    # pull_request_comments

    user = pagure.lib.search_user(session, username='pingou')

    # only 1 pull request available atm

    pr = pagure.lib.get_pull_request_of_user(session, "pingou")[0]

    item = pagure.lib.model.PullRequestComment(

        pull_request_uid=pr.uid,

        user_id=user.id,

        comment="+1 for me. Btw, could you rebase before you merge?",

        notification=0

    )

    session.add(item)

    session.commit()

    ######################################

    # pull_request_flags

    user = pagure.lib.search_user(session, username='pingou')

    # only 1 pull request available atm

    pr = pagure.lib.get_pull_request_of_user(session, "pingou")[0]

    item = pagure.lib.model.PullRequestFlag(

        uid="random_pr_flag_uid",

        pull_request_uid=pr.uid,

        user_id=user.id,

        username=user.user,

        percent=80,

        comment="Jenkins build passes",

        url=str(pr.id)

    )

    session.add(item)

    session.commit()

    ######################################

    # tags_issues

    repo = pagure.lib.get_authorized_project(session, 'test')

    issues = pagure.lib.search_issues(session, repo)

    item = pagure.lib.model.TagIssue(

        issue_uid=issues[0].uid,

        tag='Blocker',

    )

    session.add(item)

    session.commit()

    ######################################

    # tokens_acls

    tests.create_tokens_acl(session)

    ######################################

    # Fork a project

    # delete fork data

    fork_proj_location = "forks/foo/test.git"

    try:

        shutil.rmtree(os.path.join(_config['GIT_FOLDER'],

                                   fork_proj_location))

    except:

        print('git folder already deleted')

    try:

        shutil.rmtree(os.path.join(_config['DOCS_FOLDER'],

                                   fork_proj_location))

    except:

        print('docs folder already deleted')

    try:

        shutil.rmtree(os.path.join(_config['TICKETS_FOLDER'],

                                   fork_proj_location))

    except:

        print('tickets folder already deleted')

    try:

        shutil.rmtree(os.path.join(_config['REQUESTS_FOLDER'],

                                   fork_proj_location))

    except:

        print('requests folder already deleted')

    repo = pagure.lib.get_authorized_project(session, 'test')

    result = pagure.lib.fork_project(session, 'foo', repo,

                                     _config['GIT_FOLDER'],

                                     _config['DOCS_FOLDER'],

                                     _config['TICKETS_FOLDER'],

                                     _config['REQUESTS_FOLDER'])

    if result == 'Repo "test" cloned to "foo/test"':

        session.commit()

if __name__ == "__main__":

    desc = "Run the dev database initialization/insertion/deletion " \

           "script for db located  " + str(_config['DB_URL'])

    parser = argparse.ArgumentParser(prog="dev-data", description=desc)

    parser.add_argument('-i', '--init', action="store_true",

                        help="Create the dev db")

    parser.add_argument('-p', '--populate', action="store_true",

                        help="Add test data to the db")

    parser.add_argument('-d', '--delete', action="store_true",

                        help="Wipe the dev db")

    parser.add_argument('-a', '--all', action="store_true",

                        help="Create, Wipe, Populate the dev db")

    args = parser.parse_args()

    # forcing the user to choose

    if not any(vars(args).values()):

        parser.error('No arguments provided.')

    if args.init or args.delete or args.all:

        eng, meta = init_database()

    if args.delete or args.all:

        empty_dev_db(meta, eng)

    if args.populate or args.all:

        session = pagure.flask_app.SESSION

        invalid_option = ['pingou', 'bar@pingou.com', 'foo', 'foo@bar.com']

        print("")

        user_name = raw_input(

            "Enter your username so we can add you into the test data:  ")

        while user_name in invalid_option:

            print("Reserved names: " + str(invalid_option))

            user_name = raw_input(

                "Enter your username so we can add you into the test data:  ")

        if not user_name.replace(" ", ""):

            user_name = 'pythagoras'

        print("")

        user_email = raw_input("Enter your user email:  ")

        while user_email in invalid_option:

            print("Reserved names: " + str(invalid_option))

            user_email = raw_input("Enter your user email:  ")

        if not user_email.replace(" ", ""):

            user_email = 'pythagoras@math.com'

        insert_data(session, user_name, user_email)