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

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

"""

kallithea.lib.indexers.daemon

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

A daemon will read from task table and run tasks

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jan 26, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

import sys

import traceback

from os.path import dirname

from shutil import rmtree

from time import mktime

from whoosh.index import create_in, exists_in, open_dir

from whoosh.qparser import QueryParser

from kallithea.config.conf import INDEX_EXTENSIONS, INDEX_FILENAMES

from kallithea.lib.indexers import CHGSET_IDX_NAME, CHGSETS_SCHEMA, IDX_NAME, SCHEMA

from kallithea.lib.utils2 import safe_str

from kallithea.model.db import Repository

from kallithea.model.scm import ScmModel

# Add location of top level folder to sys.path

project_path = dirname(dirname(dirname(dirname(os.path.realpath(__file__)))))

sys.path.append(project_path)

log = logging.getLogger('whoosh_indexer')

class WhooshIndexingDaemon(object):

    """

    Daemon for atomic indexing jobs

    """

    def __init__(self, indexname=IDX_NAME, index_location=None,

                 repo_location=None, repo_list=None,

                 repo_update_list=None):

        self.indexname = indexname

        self.index_location = index_location

        if not index_location:

            raise Exception('You have to provide index location')

        self.repo_location = repo_location

        if not repo_location:

            raise Exception('You have to provide repositories location')

        self.repo_paths = ScmModel().repo_scan(self.repo_location)

        # filter repo list

        if repo_list:

            repo_list = set(repo_list)

            self.filtered_repo_paths = {}

            for repo_name, repo in self.repo_paths.items():

                if repo_name in repo_list:

                    self.filtered_repo_paths[repo_name] = repo

            self.repo_paths = self.filtered_repo_paths

        # filter update repo list

        self.filtered_repo_update_paths = {}

        if repo_update_list:

            self.filtered_repo_update_paths = {}

        Index files for given repo_name

        :param file_idx_writer: the whoosh index writer to add to

        :param repo_name: name of the repository we're indexing

        :param repo: instance of vcs repo

        """

        i_cnt = iwc_cnt = 0

        log.debug('Building file index for %s @revision:%s', repo_name,

                                                self._get_index_revision(repo))

        index_rev = self._get_index_revision(repo)

        for idx_path in self.get_paths(repo):

            i, iwc = self.add_doc(file_idx_writer, idx_path, repo, repo_name, index_rev)

            i_cnt += i

            iwc_cnt += iwc

        log.debug('added %s files %s with content for repo %s',

                  i_cnt + iwc_cnt, iwc_cnt, repo.path)

        return i_cnt, iwc_cnt

    def update_changeset_index(self):

        idx = open_dir(self.index_location, indexname=CHGSET_IDX_NAME)

        with idx.searcher() as searcher:

            writer = idx.writer()

            writer_is_dirty = False

            try:

                indexed_total = 0

                repo_name = None

                for repo_name, repo in sorted(self.repo_paths.items()):

                    log.debug('Updating changeset index for repo %s', repo_name)

                    # skip indexing if there aren't any revs in the repo

                    num_of_revs = len(repo)

                    if num_of_revs < 1:

                        continue

                    qp = QueryParser('repository', schema=CHGSETS_SCHEMA)

                    q = qp.parse("last:t AND %s" % repo_name)

                    results = searcher.search(q)

                    # default to scanning the entire repo

                    last_rev = 0

                    start_id = None

                    if len(results) > 0:

                        # assuming that there is only one result, if not this

                        # may require a full re-index.

                        start_id = results[0]['raw_id']

                        last_rev = repo.get_changeset(revision=start_id).revision

                    # there are new changesets to index or a new repo to index

                    if last_rev == 0 or num_of_revs > last_rev + 1:

                        # delete the docs in the index for the previous

                        # last changeset(s)

                        for hit in results:

                            q = qp.parse("last:t AND %s AND raw_id:%s" %

                                            (repo_name, hit['raw_id']))

                            writer.delete_by_query(q)

                        # index from the previous last changeset + all new ones

                        indexed_total += self.index_changesets(writer,

                                                repo_name, repo, start_id)

                        writer_is_dirty = True

                log.debug('indexed %s changesets for repo %s',

                          indexed_total, repo_name

                )

            finally:

                if writer_is_dirty:

                    log.debug('>> COMMITING CHANGES TO CHANGESET INDEX<<')

                    writer.commit(merge=True)

                    log.debug('>>> FINISHED REBUILDING CHANGESET INDEX <<<')

                else:

                    log.debug('>> NOTHING TO COMMIT TO CHANGESET INDEX<<')

    def update_file_index(self):

        log.debug('STARTING INCREMENTAL INDEXING UPDATE FOR EXTENSIONS %s '

                  'AND REPOS %s', INDEX_EXTENSIONS, ' and '.join(self.repo_paths))

        idx = open_dir(self.index_location, indexname=self.indexname)

        # The set of all paths in the index

        indexed_paths = set()

        # The set of all paths we need to re-index

        to_index = set()

        writer = idx.writer()

        writer_is_dirty = False

        try:

            with idx.reader() as reader:

                # Loop over the stored fields in the index

                for fields in reader.all_stored_fields():

                    indexed_path = fields['path']

                    indexed_repo_path = fields['repository']

                    indexed_paths.add(indexed_path)

                    if indexed_repo_path not in self.filtered_repo_update_paths:

                        continue