# 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/>.

from __future__ import with_statement

import os

import re

import time

import traceback

import logging

import cStringIO

import pkg_resources

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

from sqlalchemy import func

from pylons.i18n.translation import _

import rhodecode

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.utils2 import safe_str, safe_unicode

from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny

from rhodecode.lib.utils import get_filesystem_repos, make_ui, \

    action_logger, REMOVED_REPO_PAT

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class CachedRepoList(object):

    """

    Cached repo list, uses in-memory cache after initialization, that is

    super fast

    """

    def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):

        self.db_repo_list = db_repo_list

        self.repos_path = repos_path

        self.order_by = order_by

        self.reversed = (order_by or '').startswith('-')

        if not perm_set:

            perm_set = ['repository.read', 'repository.write',

                        'repository.admin']

        self.perm_set = perm_set

    def __len__(self):

        return len(self.db_repo_list)

    def __repr__(self):

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

    def __iter__(self):

        # pre-propagated cache_map to save executing select statements

        # for each repo

        cache_map = CacheInvalidation.get_cache_map()

        for dbr in self.db_repo_list:

            scmr = dbr.scm_instance_cached(cache_map)

            # check permission at this level

            if not HasRepoPermissionAny(

                *self.perm_set

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

                continue

                log.error(

                    '%s this repository is present in database but it '

                )

                continue

            tmp_d = {}

            tmp_d['name'] = dbr.repo_name

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

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

            tmp_d['description'] = dbr.description

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

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

            tmp_d['tip'] = tip.raw_id

            tmp_d['tip_sort'] = tip.revision

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = dbr.user.full_contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['owner_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(scmr._get_archives())

            tmp_d['last_msg'] = tip.message

            tmp_d['author'] = tip.author

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

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

            yield tmp_d

class SimpleCachedRepoList(CachedRepoList):

    """

    Lighter version of CachedRepoList without the scm initialisation

    """

    def __iter__(self):

        for dbr in self.db_repo_list:

            # check permission at this level

            if not HasRepoPermissionAny(

                *self.perm_set

            )(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['raw_name'] = 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, perm_set=None):

        """

        Creates iterator from given list of group objects, additionally

        checking permission for them from perm_set var

        :param db_repo_group_list:

        :param perm_set: list of permissons to check

        """

        self.db_repo_group_list = db_repo_group_list

        if not perm_set:

            perm_set = ['group.read', 'group.write', 'group.admin']

        self.perm_set = perm_set

    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(

                *self.perm_set

            )(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

        elif isinstance(instance, int) or safe_str(instance).isdigit():

            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