import rhodecode

from rhodecode.lib.utils import BasePasterCommand, Command, load_rcextensions

from celery.app import app_or_default

from celery.bin import camqadm, celerybeat, celeryd, celeryev

from rhodecode.lib.utils2 import str2bool

__all__ = ['CeleryDaemonCommand', 'CeleryBeatCommand',

           'CAMQPAdminCommand', 'CeleryEventCommand']

class CeleryCommand(BasePasterCommand):

    """Abstract class implements run methods needed for celery

    Starts the celery worker that uses a paste.deploy configuration

    file.

    """

    def update_parser(self):

        """

        Abstract method.  Allows for the class's parser to be updated

        before the superclass's `run` method is called.  Necessary to

        allow options/arguments to be passed through to the underlying

        celery command.

        """

        cmd = self.celery_command(app_or_default())

        for x in cmd.get_options():

            self.parser.add_option(x)

    def command(self):

        from pylons import config

        try:

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

        except KeyError:

            CELERY_ON = False

            raise Exception('Please enable celery_on in .ini config '

                            'file before running celeryd')

        rhodecode.CELERY_ON = CELERY_ON

        load_rcextensions(config['here'])

        cmd = self.celery_command(app_or_default())

        return cmd.run(**vars(self.options))

class CeleryDaemonCommand(CeleryCommand):

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

    celery_command = celeryd.WorkerCommand

class CeleryBeatCommand(CeleryCommand):

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

    celery_command = celerybeat.BeatCommand

class CAMQPAdminCommand(CeleryCommand):

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

    celery_command = camqadm.AMQPAdminCommand

    def __str__(self):

        return str(self.value)

    def __int__(self):

        return int(self.value)

class Collection(pathed.Pathed):

    """A collection of versioning scripts in a repository"""

    FILENAME_WITH_VERSION = re.compile(r'^(\d{3,}).*')

    def __init__(self, path):

        """Collect current version scripts in repository

        and store them in self.versions

        """

        super(Collection, self).__init__(path)

        # Create temporary list of files, allowing skipped version numbers.

        files = os.listdir(path)

        if '1' in files:

            # deprecation

            raise Exception('It looks like you have a repository in the old '

                'format (with directories for each version). '

                'Please convert repository before proceeding.')

        tempVersions = dict()

        for filename in files:

            match = self.FILENAME_WITH_VERSION.match(filename)

            if match:

                num = int(match.group(1))

                tempVersions.setdefault(num, []).append(filename)

            else:

                pass  # Must be a helper file or something, let's ignore it.

        # Create the versions member where the keys

        # are VerNum's and the values are Version's.

        self.versions = dict()

        for num, files in tempVersions.items():

            self.versions[VerNum(num)] = Version(num, path, files)

    @property

    def latest(self):

        """:returns: Latest version in Collection"""

        return max([VerNum(0)] + self.versions.keys())

    def _next_ver_num(self, use_timestamp_numbering):

            return VerNum(int(datetime.utcnow().strftime('%Y%m%d%H%M%S')))

        else:

            return self.latest + 1

    def create_new_python_version(self, description, **k):

        """Create Python files for new version"""

        ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))

        extra = str_to_filename(description)

        if extra:

            if extra == '_':

                extra = ''

            elif not extra.startswith('_'):

                extra = '_%s' % extra

        filename = '%03d%s.py' % (ver, extra)

        filepath = self._version_path(filename)

        script.PythonScript.create(filepath, **k)

        self.versions[ver] = Version(ver, self.path, [filename])

    def create_new_sql_version(self, database, description, **k):

        """Create SQL files for new version"""

        ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))

        self.versions[ver] = Version(ver, self.path, [])

        extra = str_to_filename(description)

        if extra:

            if extra == '_':

                extra = ''

            elif not extra.startswith('_'):

                extra = '_%s' % extra

        # Create new files.

        for op in ('upgrade', 'downgrade'):

            filename = '%03d%s_%s_%s.sql' % (ver, extra, database, op)

            filepath = self._version_path(filename)

            script.SqlScript.create(filepath, **k)

            self.versions[ver].add_script(filepath)

    def version(self, vernum=None):

        """Returns latest Version if vernum is not given.

        Otherwise, returns wanted version"""

        if vernum is None:

            vernum = self.latest

        return self.versions[VerNum(vernum)]

                    log.error(traceback.format_exc())

                    sa.rollback()

    return added, removed

# set cache regions for beaker so celery can utilise it

def add_cache(settings):

    cache_settings = {'regions': None}

    for key in settings.keys():

        for prefix in ['beaker.cache.', 'cache.']:

            if key.startswith(prefix):

                name = key.split(prefix)[1].strip()

                cache_settings[name] = settings[key].strip()

    if cache_settings['regions']:

        for region in cache_settings['regions'].split(','):

            region = region.strip()

            region_settings = {}

            for key, value in cache_settings.items():

                if key.startswith(region):

                    region_settings[key.split('.')[1]] = value

            region_settings['expire'] = int(region_settings.get('expire',

                                                                60))

            region_settings.setdefault('lock_dir',

                                       cache_settings.get('lock_dir'))

            region_settings.setdefault('data_dir',

                                       cache_settings.get('data_dir'))

            if 'type' not in region_settings:

                region_settings['type'] = cache_settings.get('type',

                                                             'memory')

            beaker.cache.cache_regions[region] = region_settings

def load_rcextensions(root_path):

    import rhodecode

    from rhodecode.config import conf

    path = os.path.join(root_path, 'rcextensions', '__init__.py')

    if os.path.isfile(path):

        rcext = create_module('rc', path)

        EXT = rhodecode.EXTENSIONS = rcext

        log.debug('Found rcextensions now loading %s...' % rcext)

        # Additional mappings that are not present in the pygments lexers

        conf.LANGUAGES_EXTENSIONS_MAP.update(getattr(EXT, 'EXTRA_MAPPINGS', {}))

        #OVERRIDE OUR EXTENSIONS FROM RC-EXTENSIONS (if present)

            log.debug('settings custom INDEX_EXTENSIONS')

            conf.INDEX_EXTENSIONS = getattr(EXT, 'INDEX_EXTENSIONS', [])

        #ADDITIONAL MAPPINGS

        log.debug('adding extra into INDEX_EXTENSIONS')

        conf.INDEX_EXTENSIONS.extend(getattr(EXT, 'EXTRA_INDEX_EXTENSIONS', []))

        # auto check if the module is not missing any data, set to default if is

        # this will help autoupdate new feature of rcext module

        from rhodecode.config import rcextensions

        for k in dir(rcextensions):

            if not k.startswith('_') and not hasattr(EXT, k):

                setattr(EXT, k, getattr(rcextensions, k))

def get_custom_lexer(extension):

    """

    returns a custom lexer if it's defined in rcextensions module, or None

    if there's no custom lexer defined

    """

    import rhodecode

    from pygments import lexers

    #check if we didn't define this extension as other lexer

    if rhodecode.EXTENSIONS and extension in rhodecode.EXTENSIONS.EXTRA_LEXERS:

        _lexer_name = rhodecode.EXTENSIONS.EXTRA_LEXERS[extension]

        return lexers.get_lexer_by_name(_lexer_name)

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

# TEST FUNCTIONS AND CREATORS

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

def create_test_index(repo_location, config, full_index):

    """

    Makes default test index

    :param config: test config

    :param full_index:

    """

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    from rhodecode.lib.pidlock import DaemonLock, LockHeld

    repo_location = repo_location

    index_location = os.path.join(config['app_conf']['index_dir'])

    if not os.path.exists(index_location):

        os.makedirs(index_location)

        DEFAULT_PERMS = Permission.DEFAULT_USER_PERMISSIONS

        # for every default permission that needs to be created, we check if

        # it's group is already defined, if it's not we create default perm

        for perm_name in DEFAULT_PERMS:

            gr = _get_group(perm_name)

            if gr not in defined_perms_groups:

                log.debug('GR:%s not found, creating permission %s'

                          % (gr, perm_name))

                new_perm = _make_perm(perm_name)

                self.sa.add(new_perm)

    def update(self, form_result):

        perm_user = User.get_by_username(username=form_result['perm_user_name'])

        try:

            # stage 1 set anonymous access

            if perm_user.username == 'default':

                perm_user.active = str2bool(form_result['anonymous'])

                self.sa.add(perm_user)

            # stage 2 reset defaults and set them from form data

            def _make_new(usr, perm_name):

                log.debug('Creating new permission:%s' % (perm_name))

                new = UserToPerm()

                new.user = usr

                new.permission = Permission.get_by_key(perm_name)

                return new

            # clear current entries, to make this function idempotent

            # it will fix even if we define more permissions or permissions

            # are somehow missing

            u2p = self.sa.query(UserToPerm)\

                .filter(UserToPerm.user == perm_user)\

                .all()

            for p in u2p:

                self.sa.delete(p)

            #create fresh set of permissions

            for def_perm_key in ['default_repo_perm', 'default_group_perm',

                                 'default_user_group_perm',

                                 'default_repo_create',

                                 #'default_repo_group_create', #not implemented yet

                                 'default_user_group_create',

                                 'default_fork', 'default_register',

                                 'default_extern_activate']:

                p = _make_new(perm_user, form_result[def_perm_key])

                self.sa.add(p)

            #stage 3 update all default permissions for repos if checked

                _def_name = form_result['default_repo_perm'].split('repository.')[-1]

                _def = Permission.get_by_key('repository.' + _def_name)

                # repos

                for r2p in self.sa.query(UserRepoToPerm)\

                               .filter(UserRepoToPerm.user == perm_user)\

                               .all():

                    #don't reset PRIVATE repositories

                    if not r2p.repository.private:

                        r2p.permission = _def

                        self.sa.add(r2p)

                _def_name = form_result['default_group_perm'].split('group.')[-1]

                # groups

                _def = Permission.get_by_key('group.' + _def_name)

                for g2p in self.sa.query(UserRepoGroupToPerm)\

                               .filter(UserRepoGroupToPerm.user == perm_user)\

                               .all():

                    g2p.permission = _def

                    self.sa.add(g2p)

                _def_name = form_result['default_user_group_perm'].split('usergroup.')[-1]

                # groups

                _def = Permission.get_by_key('usergroup.' + _def_name)

                for g2p in self.sa.query(UserUserGroupToPerm)\

                               .filter(UserUserGroupToPerm.user == perm_user)\

                               .all():

                    g2p.permission = _def

                    self.sa.add(g2p)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise