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

"""

    rhodecode.lib.db_manage

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

    Database creation, and setup module for RhodeCode. Used for creation

    of database as well as for migration operations

    :created_on: Apr 10, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import os

import sys

import uuid

import logging

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

from rhodecode import __dbversion__, __py_version__

from rhodecode.model.user import UserModel

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

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

    RhodeCodeSetting, UserToPerm, DbMigrateVersion, RepoGroup, \

from sqlalchemy.engine import create_engine

from rhodecode.model.repos_group import ReposGroupModel

#from rhodecode.model import meta

from rhodecode.model.meta import Session, Base

from rhodecode.model.repo import RepoModel

from rhodecode.model.permission import PermissionModel

log = logging.getLogger(__name__)

def notify(msg):

    """

    Notification for migrations messages

    """

    ml = len(msg) + (4 * 2)

    print >> sys.stdout, ('*** %s ***\n%s' % (msg, '*' * ml)).upper()

class DbManage(object):

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

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

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.log_sql = log_sql

        self.db_exists = False

        self.cli_args = cli_args

        self.init_db()

        force_ask = self.cli_args.get('force_ask')

        if force_ask is not None:

            global ask_ok

            ask_ok = lambda *args, **kwargs: force_ask

    def init_db(self):

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

        init_model(engine)

        self.sa = Session()

    def create_tables(self, override=False):

        """

        Create a auth database

        """

        log.info("Any existing database is 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('Nothing tables created')

        if destroy:

            Base.metadata.drop_all()

                hooks4.ui_key = RhodeCodeUi.HOOK_PRE_PUSH

                hooks4.ui_value = 'python:rhodecode.lib.hooks.pre_push'

                Session().add(hooks4)

                notify('installing new pre-pull hook')

                hooks6 = RhodeCodeUi()

                hooks6.ui_section = 'hooks'

                hooks6.ui_key = RhodeCodeUi.HOOK_PRE_PULL

                hooks6.ui_value = 'python:rhodecode.lib.hooks.pre_pull'

                Session().add(hooks6)

                notify('installing hgsubversion option')

                # enable hgsubversion disabled by default

                hgsubversion = RhodeCodeUi()

                hgsubversion.ui_section = 'extensions'

                hgsubversion.ui_key = 'hgsubversion'

                hgsubversion.ui_value = ''

                hgsubversion.ui_active = False

                Session().add(hgsubversion)

                notify('installing hg git option')

                # enable hggit disabled by default

                hggit = RhodeCodeUi()

                hggit.ui_section = 'extensions'

                hggit.ui_key = 'hggit'

                hggit.ui_value = ''

                hggit.ui_active = False

                Session().add(hggit)

                notify('re-check default permissions')

                default_user = User.get_by_username(User.DEFAULT_USER)

                perm = Permission.get_by_key('hg.fork.repository')

                reg_perm = UserToPerm()

                reg_perm.user = default_user

                reg_perm.permission = perm

                Session().add(reg_perm)

            def step_7(self):

                perm_fixes = self.klass.reset_permissions(User.DEFAULT_USER)

                Session().commit()

                if perm_fixes:

                    notify('There was an inconsistent state of permissions '

                           'detected for default user. Permissions are now '

                           'reset to the default value for default user. '

                           'Please validate and check default permissions '

                           'in admin panel')

            def step_8(self):

                self.klass.populate_default_permissions()

                self.klass.create_default_options(skip_existing=True)

                Session().commit()

            def step_9(self):

                perm_fixes = self.klass.reset_permissions(User.DEFAULT_USER)

                Session().commit()

                if perm_fixes:

                    notify('There was an inconsistent state of permissions '

                           'detected for default user. Permissions are now '

                           'reset to the default value for default user. '

                           'Please validate and check default permissions '

                           'in admin panel')

            def step_10(self):

                pass

            def step_11(self):

                self.klass.update_repo_info()

            def step_12(self):

                self.klass.create_permissions()

                self.klass.populate_default_permissions()

        upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)

        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        _step = None

        for step in upgrade_steps:

            notify('performing upgrade step %s' % step)

            getattr(UpgradeSteps(self), 'step_%s' % step)()

            self.sa.commit()

            _step = step

        notify('upgrade to version %s successful' % _step)

    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 Exception:

            self.sa.rollback()

            raise

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

        def_user = self.sa.query(User)\

                .filter(User.username == 'default')\

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@rhodecode.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

        except Exception: