from celery.decorators import task

import os

import traceback

from time import mktime

from operator import itemgetter

from pylons import config

from pylons.i18n.translation import _

from rhodecode.lib.celerylib import run_task, locked_task, str2bool

from rhodecode.lib.helpers import person

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.model import init_model

from rhodecode.model import meta

from rhodecode.model.db import RhodeCodeUi

from vcs.backends import get_repo

from sqlalchemy import engine_from_config

add_cache(config)

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

__all__ = ['whoosh_index', 'get_commits_stats',

           'reset_user_password', 'send_email']

CELERY_ON = str2bool(config['app_conf'].get('use_celery'))

def get_session():

    if CELERY_ON:

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

    sa = meta.Session()

    return sa

def get_repos_path():

    sa = get_session()

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

    return q.ui_value

@task

@locked_task

def whoosh_index(repo_location, full_index):

    log = whoosh_index.get_logger()

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location, sa=get_session())\

                         .run(full_index=full_index)

@task

@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    #for js data compatibilty

    author_key_cleaner = lambda k: person(k).replace('"', "")

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repos_path = get_repos_path()

    p = os.path.join(repos_path, repo_name)

__all__ = ['CeleryDaemonCommand', 'CeleryBeatCommand',

           'CAMQPAdminCommand', 'CeleryEventCommand']

    """Start the celery worker

    Starts the celery worker that uses a paste.deploy configuration

    file.

    """

    usage = 'CONFIG_FILE [celeryd options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    def update_parser(self):

        from celery.bin import celeryd

        for x in celeryd.WorkerCommand().get_options():

            self.parser.add_option(x)

    def command(self):

        from celery.bin import celeryd

        return celeryd.WorkerCommand().run(**vars(self.options))

    """Start the celery beat server

    Starts the celery beat server using a paste.deploy configuration

    file.

    """

    usage = 'CONFIG_FILE [celerybeat options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    def update_parser(self):

        from celery.bin import celerybeat

        for x in celerybeat.BeatCommand().get_options():

            self.parser.add_option(x)

    def command(self):

        from celery.bin import celerybeat

        return celerybeat.BeatCommand(**vars(self.options))

    """CAMQP Admin

    CAMQP celery admin tool.

    """

    usage = 'CONFIG_FILE [camqadm options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    def update_parser(self):

        from celery.bin import camqadm

        for x in camqadm.OPTION_LIST:

            self.parser.add_option(x)

    def command(self):

        from celery.bin import camqadm

        return camqadm.camqadm(*self.args, **vars(self.options))

    """Celery event commandd.

    Capture celery events.

    """

    usage = 'CONFIG_FILE [celeryev options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    def update_parser(self):

        from celery.bin import celeryev

        for x in celeryev.OPTION_LIST:

            self.parser.add_option(x)

    def command(self):

        from celery.bin import celeryev

        return celeryev.run_celeryev(**vars(self.options))

import os

import sys

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

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from rhodecode.config.environment import load_environment

from shutil import rmtree

from webhelpers.html.builder import escape

from vcs.utils.lazy import LazyProperty

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, Schema, FieldType

from whoosh.index import create_in, open_dir

from whoosh.formats import Characters

from whoosh.highlight import highlight, SimpleFragmenter, HtmlFormatter

#EXTENSIONS WE WANT TO INDEX CONTENT OFF

INDEX_EXTENSIONS = ['action', 'adp', 'ashx', 'asmx', 'aspx', 'asx', 'axd', 'c',

                    'cfg', 'cfm', 'cpp', 'cs', 'css', 'diff', 'do', 'el', 'erl',

                    'h', 'htm', 'html', 'ini', 'java', 'js', 'jsp', 'jspx', 'lisp',

                    'lua', 'm', 'mako', 'ml', 'pas', 'patch', 'php', 'php3',

                    'php4', 'phtml', 'pm', 'py', 'rb', 'rst', 's', 'sh', 'sql',

                    'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt',

                    'yaws']

#CUSTOM ANALYZER wordsplit + lowercase filter

ANALYZER = RegexTokenizer(expression=r"\w+") | LowercaseFilter()

#INDEX SCHEMA DEFINITION

SCHEMA = Schema(owner=TEXT(),

                repository=TEXT(stored=True),

                path=TEXT(stored=True),

                content=FieldType(format=Characters(ANALYZER),

                             scorable=True, stored=True),

                modtime=STORED(), extension=TEXT(stored=True))

IDX_NAME = 'HG_INDEX'

FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n')

FRAGMENTER = SimpleFragmenter(200)

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Creates index for full text search given configuration file"

    group_name = "RhodeCode"

    takes_config_file = -1

    def command(self):

        repo_location = self.options.repo_location

        #======================================================================

        # WHOOSH DAEMON

        #======================================================================

        from rhodecode.lib.pidlock import LockHeld, DaemonLock

        from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

        try:

            l = DaemonLock()

            WhooshIndexingDaemon(index_location=index_location,

                                 repo_location=repo_location)\

                .run(full_index=self.options.full_index)

            l.release()

        except LockHeld:

            sys.exit(1)

class ResultWrapper(object):

    def __init__(self, search_type, searcher, matcher, highlight_items):

        self.search_type = search_type

        self.searcher = searcher

        self.matcher = matcher

        self.highlight_items = highlight_items

        self.fragment_size = 200 / 2

    @LazyProperty

    def doc_ids(self):

        docs_id = []

        while self.matcher.is_active():

            docnum = self.matcher.id()

            chunks = [offsets for offsets in self.get_chunks()]

            docs_id.append([docnum, chunks])

            self.matcher.next()

        return docs_id

    def __str__(self):

        return '<%s at %s>' % (self.__class__.__name__, len(self.doc_ids))

    def __repr__(self):

        return self.__str__()

    def __len__(self):

        return len(self.doc_ids)

    def __iter__(self):

        """

        Allows Iteration over results,and lazy generate content

        *Requires* implementation of ``__getitem__`` method.

        """

        for docid in self.doc_ids:

            yield self.get_full_content(docid)

    def __getslice__(self, i, j):

        """

        Slicing of resultWrapper

        """

        slice = []

        for docid in self.doc_ids[i:j]:

            slice.append(self.get_full_content(docid))

        return slice

    def get_full_content(self, docid):

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

"""

    package.rhodecode.lib.utils

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

    Utilities library for RhodeCode

    :created_on: Apr 18, 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 logging

import datetime

import traceback

import ConfigParser

from UserDict import DictMixin

from mercurial import ui, config, hg

from mercurial.error import RepoError

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty

from rhodecode.model import meta

from rhodecode.model.caching_query import FromCache

from rhodecode.model.db import Repository, User, RhodeCodeUi, UserLog

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

def get_repo_slug(request):

    return request.environ['pylons.routes_dict'].get('repo_name')

def action_logger(user, action, repo, ipaddr='', sa=None):

    """

    Action logger for various actions made by users

    :param user: user that made this action, can be a unique username string or

        object containing user_id attribute

    :param action: action to log, should be on of predefined unique actions for

        easy translations

    :param repo: string name of repository or object containing repo_id,

        that action was made on

    :param ipaddr: optional ip address from what the action was made

    :param sa: optional sqlalchemy session

    """

    if not sa:

        sa = meta.Session()

    try:

        um = UserModel()

        if hasattr(user, 'user_id'):

            user_obj = user

        elif isinstance(user, basestring):

            user_obj = um.get_by_username(user, cache=False)

        else:

            raise Exception('You have to provide user object or username')

        rm = RepoModel()

        if hasattr(repo, 'repo_id'):

            repo_obj = rm.get(repo.repo_id, cache=False)

            repo_name = repo_obj.repo_name

        elif  isinstance(repo, basestring):

        return key, value

    def __reduce__(self):

        items = [[k, self[k]] for k in self]

        tmp = self.__map, self.__end

        del self.__map, self.__end

        inst_dict = vars(self).copy()

        self.__map, self.__end = tmp

        if inst_dict:

            return (self.__class__, (items,), inst_dict)

        return self.__class__, (items,)

    def keys(self):

        return list(self)

    setdefault = DictMixin.setdefault

    update = DictMixin.update

    pop = DictMixin.pop

    values = DictMixin.values

    items = DictMixin.items

    iterkeys = DictMixin.iterkeys

    itervalues = DictMixin.itervalues

    iteritems = DictMixin.iteritems

    def __repr__(self):

        if not self:

            return '%s()' % (self.__class__.__name__,)

        return '%s(%r)' % (self.__class__.__name__, self.items())

    def copy(self):

        return self.__class__(self)

    @classmethod

    def fromkeys(cls, iterable, value=None):

        d = cls()

        for key in iterable:

            d[key] = value

        return d

    def __eq__(self, other):

        if isinstance(other, OrderedDict):

            return len(self) == len(other) and self.items() == other.items()

        return dict.__eq__(self, other)

    def __ne__(self, other):

        return not self == other

#===============================================================================

# TEST FUNCTIONS AND CREATORS

#===============================================================================

def create_test_index(repo_location, full_index):

    """Makes default test index

    :param repo_location:

    :param full_index:

    """

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    from rhodecode.lib.pidlock import DaemonLock, LockHeld

    import shutil

    index_location = os.path.join(repo_location, 'index')

    if os.path.exists(index_location):

        shutil.rmtree(index_location)

    try:

        l = DaemonLock()

        WhooshIndexingDaemon(index_location=index_location,

                             repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """Makes a fresh database and 

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    from rhodecode.tests import HG_REPO, GIT_REPO, NEW_HG_REPO, NEW_GIT_REPO, \

        HG_FORK, GIT_FORK, TESTS_TMP_PATH

    import tarfile

    import shutil

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

    log = logging.getLogger('TestEnvCreator')

    # create logger

    log.setLevel(logging.DEBUG)

    log.propagate = True

    # create console handler and set level to debug

    ch = logging.StreamHandler()

    ch.setLevel(logging.DEBUG)

    # create formatter

    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")

    # add formatter to ch

    ch.setFormatter(formatter)

    # add ch to logger

    log.addHandler(ch)

    #PART ONE create db

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

    log.debug('making test db %s', dbconf)

    dbmanage = DbManage(log_sql=True, dbconf=dbconf, root=config['here'],

                        tests=True)

    dbmanage.create_tables(override=True)

    dbmanage.config_prompt(repos_test_path)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    #PART TWO make test repo

    log.debug('making test vcs repositories')

    #remove old one from previos tests

    for r in [HG_REPO, GIT_REPO, NEW_HG_REPO, NEW_GIT_REPO, HG_FORK, GIT_FORK]:

        if os.path.isdir(jn(TESTS_TMP_PATH, r)):

            log.debug('removing %s', r)

            shutil.rmtree(jn(TESTS_TMP_PATH, r))

    #CREATE DEFAULT HG REPOSITORY

    cur_dir = dn(dn(abspath(__file__)))

    tar = tarfile.open(jn(cur_dir, 'tests', "vcs_test_hg.tar.gz"))

    tar.extractall(jn(TESTS_TMP_PATH, HG_REPO))

    tar.close()

    """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"

                      action='store_true',

                      dest='just_sql',

                      help="Prints upgrade sql for further investigation",

                      default=False)