# -*- coding: utf-8 -*-

"""

    rhodecode.lib.db_manage

    ~~~~~~~~~~~~~~~~~~~~~~~

    :created_on: Apr 10, 2010

    :author: marcink

    :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import os

import sys

import uuid

import logging

from os.path import dirname as dn, join as jn

from rhodecode import __dbversion__

from rhodecode.model import meta

from rhodecode.lib.auth import get_crypt_password

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

from rhodecode.model.db import User, Permission, RhodeCodeUi, RhodeCodeSettings, \

    UserToPerm, DbMigrateVersion

from sqlalchemy.engine import create_engine

log = logging.getLogger(__name__)

class DbManage(object):

    def __init__(self, log_sql, dbconf, root, tests=False):

        self.dbname = dbconf.split('/')[-1]

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        engine = create_engine(self.dburi, echo=log_sql)

        self.check_for_db(override)

        if self.db_exists:

            log.info("database exist and it's going to be destroyed")

            if self.tests:

                destroy = True

            else:

                destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

            if not destroy:

                sys.exit()

            if self.db_exists and destroy:

                os.remove(jn(self.root, self.dbname))

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s', self.dbname)

    def set_db_version(self):

        try:

            ver = DbMigrateVersion()

            ver.version = __dbversion__

            ver.repository_id = 'rhodecode_db_migrations'

            ver.repository_path = 'versions'

            self.sa.add(ver)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

        log.info('db version set to: %s', __dbversion__)

    def fix_repo_paths(self):

        """Fixes a old rhodecode version path into new one without a '*'

        """

        paths = self.sa.query(RhodeCodeUi)\

                .filter(RhodeCodeUi.ui_key == '/')\

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

            self.sa.add(paths)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def admin_prompt(self, second=False):

        if not self.tests:

            import getpass

            def get_password():

                password = getpass.getpass('Specify admin password (min 6 chars):')

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

                if len(password) < 6:

                    log.error('password is to short use at least 6 characters')

                    return False

                return password

            username = raw_input('Specify admin username:')

            password = get_password()

            if not password:

                #second try

                password = get_password()

                if not password:

                    sys.exit()

            email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            self.create_user('test_admin', 'test12', 'test_admin@mail.com', True)

            self.create_user('test_regular', 'test12', 'test_regular@mail.com', False)

            self.create_user('test_regular2', 'test12', 'test_regular2@mail.com', False)

    def create_ui_settings(self):

        """Creates ui settings, fills out hooks

        and disables dotencode

        """

        #HOOKS

        hooks1_key = 'changegroup.update'

        hooks1_ = self.sa.query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == hooks1_key).scalar()

        hooks1 = RhodeCodeUi() if hooks1_ is None else hooks1_

from rhodecode.lib.db_manage import DbManage

log = logging.getLogger(__name__)

class UpgradeDb(BasePasterCommand):

    """Command used for paster to upgrade our database to newer version

    """

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Upgrades current db to newer version given configuration file"

    group_name = "RhodeCode"

    parser = Command.standard_parser(verbose=True)

    def command(self):

        from pylons import config

        add_cache(config)

        repository_path = 'rhodecode/lib/dbmigrate'

        db_uri = config['sqlalchemy.db1.url']

        try:

            curr_version = api.db_version(db_uri, repository_path)

            msg = ('Found current database under version'

                 ' control with version %s' % curr_version)

        except (RuntimeError, DatabaseNotControlledError), e:

            curr_version = 1

            msg = ('Current database is not under version control setting'

                   ' as version %s' % curr_version)

            api.version_control(db_uri, repository_path, curr_version)

        self.notify_msg(msg)

        #now we have our dbversion we can do upgrade

        self.notify_msg('attempting to do database upgrade to version %s' \

                        % __dbversion__)

        api.upgrade(db_uri, repository_path, __dbversion__)

        self.notify_msg('Schema upgrade completed')

        #we need to make now some extra operations into database

        dbmanage = DbManage(log_sql=True, dbconf=db_uri,

                            root=config['here'], tests=False)

        dbmanage.fix_repo_paths()

        self.notify_msg('Changing ui settings')

        dbmanage.create_ui_settings()

    def update_parser(self):

        self.parser.add_option('--sql',

                      action='store_true',

                      dest='just_sql',

                      help="Prints upgrade sql for further investigation",

                      default=False)