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

"""

    rhodecode.model.__init__

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

    The application's model objects

    :created_on: Nov 25, 2010

    :author: marcink

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

    :license: GPLv3, see COPYING for more details.

    :example:

        .. code-block:: python

           from paste.deploy import appconfig

           from pylons import config

           from sqlalchemy import engine_from_config

           from rhodecode.config.environment import load_environment

           conf = appconfig('config:development.ini', relative_to = './../../')

           load_environment(conf.global_conf, conf.local_conf)

           engine = engine_from_config(config, 'sqlalchemy.')

           init_model(engine)

           # RUN YOUR CODE HERE

"""

# 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 logging

from rhodecode.model import meta

log = logging.getLogger(__name__)

def init_model(engine):

    """

    Initializes db session, bind the engine with the metadata,

    Call this before using any of the tables or classes in the model,

    preferably once in application start

    :param engine: engine to bind to

    """

    log.info("initializing db for %s" % engine)

    meta.Base.metadata.bind = engine

class BaseModel(object):

    """

    Base Model for all RhodeCode models, it adds sql alchemy session

    into instance of model

    :param sa: If passed it reuses this session instead of creating a new one

    """

    cls = None  # override in child class

    def __init__(self, sa=None):

        if sa is not None:

            self.sa = sa

        else:

            self.sa = meta.Session()

    def _get_instance(self, cls, instance, callback=None):

        """

        Get's instance of given cls using some simple lookup mechanism.

        :param cls: class to fetch

        :param instance: int or Instance

        :param callback: callback to call if all lookups failed

        """

        if isinstance(instance, cls):

            return instance

            return cls.get(instance)

        else:

            if instance:

                if callback is None:

                    raise Exception(

                        'given object must be int, long or Instance of %s '

                        'got %s, no callback provided' % (cls, type(instance))

                    )

                else:

                    return callback(instance)

    def _get_user(self, user):

        """

        Helper method to get user by ID, or username fallback

        :param user:

        :type user: UserID, username, or User instance

        """

        from rhodecode.model.db import User

        return self._get_instance(User, user,

                                  callback=User.get_by_username)

    def _get_repo(self, repository):

        """

        Helper method to get repository by ID, or repository name

        :param repository:

        :type repository: RepoID, repository name or Repository Instance

        """

        from rhodecode.model.db import Repository

        return self._get_instance(Repository, repository,

                                  callback=Repository.get_by_repo_name)

    def _get_perm(self, permission):

        """

        Helper method to get permission by ID, or permission name

        :param permission:

        :type permission: PermissionID, permission_name or Permission instance

        """

        from rhodecode.model.db import Permission

        return self._get_instance(Permission, permission,

                                  callback=Permission.get_by_key)

    def get_all(self):

        """

        Returns all instances of what is defined in `cls` class variable

        """

        for dbr in self.db_repo_list:

            # check permission at this level

            if not HasRepoPermissionAny(

                'repository.read', 'repository.write', 'repository.admin'

            )(dbr.repo_name, 'get repo check'):

                continue

            tmp_d = {}

            tmp_d['name'] = dbr.repo_name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['description'] = dbr.description

            tmp_d['description_sort'] = tmp_d['description'].lower()

            tmp_d['dbrepo'] = dbr.get_dict()

            tmp_d['dbrepo_fork'] = dbr.fork.get_dict() if dbr.fork else {}

            yield tmp_d

class GroupList(object):

    def __init__(self, db_repo_group_list):

        self.db_repo_group_list = db_repo_group_list

    def __len__(self):

        return len(self.db_repo_group_list)

    def __repr__(self):

        return '<%s (%s)>' % (self.__class__.__name__, self.__len__())

    def __iter__(self):

        for dbgr in self.db_repo_group_list:

            # check permission at this level

            if not HasReposGroupPermissionAny(

                'group.read', 'group.write', 'group.admin'

            )(dbgr.group_name, 'get group repo check'):

                continue

            yield dbgr

class ScmModel(BaseModel):

    """

    Generic Scm Model

    """

    def __get_repo(self, instance):

        cls = Repository

        if isinstance(instance, cls):

            return instance

            return cls.get(instance)

        elif isinstance(instance, basestring):

            return cls.get_by_repo_name(instance)

        elif instance:

            raise Exception('given object must be int, basestr or Instance'

                            ' of %s got %s' % (type(cls), type(instance)))

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path=None):

        """

        Listing of repositories in given path. This path should not be a

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

        """

        if repos_path is None:

            repos_path = self.repos_path

        log.info('scanning for repositories in %s' % repos_path)

        baseui = make_ui('db')

        repos = {}

        for name, path in get_filesystem_repos(repos_path, recursive=True):

            # skip removed repos

            if REMOVED_REPO_PAT.match(name):

                continue

            # name need to be decomposed and put back together using the /

            # since this is internal storage separator for rhodecode

            name = Repository.url_sep().join(name.split(os.sep))

            try:

                if name in repos:

                    raise RepositoryError('Duplicate repository name %s '

                                          'found in %s' % (name, path))

                else:

        choices.extend([x[0] for x in tags_group[0]])

        return choices, hist_l

    def install_git_hook(self, repo, force_create=False):

        """

        Creates a rhodecode hook inside a git repository

        :param repo: Instance of VCS repo

        :param force_create: Create even if same name hook exists

        """

        loc = jn(repo.path, 'hooks')

        if not repo.bare:

            loc = jn(repo.path, '.git', 'hooks')

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl = pkg_resources.resource_string(

            'rhodecode', jn('config', 'post_receive_tmpl.py')

        )

        _hook_file = jn(loc, 'post-receive')

        _rhodecode_hook = False

        log.debug('Installing git hook in repo %s' % repo)

        if os.path.exists(_hook_file):

            # let's take a look at this hook, maybe it's rhodecode ?

            log.debug('hook exists, checking if it is from rhodecode')

            _HOOK_VER_PAT = re.compile(r'^RC_HOOK_VER')

            with open(_hook_file, 'rb') as f:

                data = f.read()

                matches = re.compile(r'(?:%s)\s*=\s*(.*)'

                                     % 'RC_HOOK_VER').search(data)

                if matches:

                    try:

                        ver = matches.groups()[0]

                        log.debug('got %s it is rhodecode' % (ver))

                        _rhodecode_hook = True

                    except:

                        log.error(traceback.format_exc())

        if _rhodecode_hook or force_create:

            log.debug('writing hook file !')

            with open(_hook_file, 'wb') as f:

                tmpl = tmpl.replace('_TMPL_', rhodecode.__version__)

                f.write(tmpl)

            os.chmod(_hook_file, 0755)

        else: