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

"""

    rhodecode.lib.indexers.__init__

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

    Whoosh indexing module for RhodeCode

    :created_on: Aug 17, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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, 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 os

import sys

import traceback

import logging

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 string import strip

from shutil import rmtree

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, HtmlFormatter, ContextFragmenter

from sqlalchemy import engine_from_config

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.config.environment import load_environment

from rhodecode.lib.utils2 import LazyProperty

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache,\

    load_rcextensions

# CUSTOM ANALYZER wordsplit + lowercase filter

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

#INDEX SCHEMA DEFINITION

SCHEMA = Schema(

    fileid=ID(unique=True),

    owner=TEXT(),

    repository=TEXT(stored=True),

    path=TEXT(stored=True),

    content=FieldType(format=Characters(), analyzer=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 = ContextFragmenter(200)

class MakeIndex(BasePasterCommand):

    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

    parser = Command.standard_parser(verbose=True)

    def command(self):

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        add_cache(config)

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

        init_model(engine)

        slices = []

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

            slices.append(self.get_full_content(docid))

        return slices

    def get_full_content(self, docid):

        res = self.searcher.stored_fields(docid[0])

        full_repo_path = jn(self.repo_location, res['repository'])

        f_path = res['path'].split(full_repo_path)[-1]

        f_path = f_path.lstrip(os.sep)

        content_short = self.get_short_content(res, docid[1])

        res.update({'content_short': content_short,

                    'content_short_hl': self.highlight(content_short),

                    'f_path': f_path})

        return res

    def get_short_content(self, res, chunks):

        return ''.join([res['content'][chunk[0]:chunk[1]] for chunk in chunks])

    def get_chunks(self):

        """

        Smart function that implements chunking the content

        but not overlap chunks so it doesn't highlight the same

        close occurrences twice.

        :param matcher:

        :param size:

        """

        memory = [(0, 0)]

        for span in self.matcher.spans():

            start = span.startchar or 0

            end = span.endchar or 0

            start_offseted = max(0, start - self.fragment_size)

            end_offseted = end + self.fragment_size

            if start_offseted < memory[-1][1]:

                start_offseted = memory[-1][1]

            memory.append((start_offseted, end_offseted,))

            yield (start_offseted, end_offseted,)

    def highlight(self, content, top=5):

        if self.search_type != 'content':

            return ''

        hl = highlight(

            terms=self.highlight_items,

            analyzer=ANALYZER,

            fragmenter=FRAGMENTER,

            formatter=FORMATTER,

            top=top

        )

        return hl

<div class="box">

	<!-- box / title -->

	<div class="title">

		<h5>${_('Search')}

		%if c.repo_name:

			${_('in repository: ') + c.repo_name}

		%else:

			${_('in all repositories')}

		%endif

		</h5>

	</div>

	<!-- end box / title -->

	%if c.repo_name:

		${h.form(h.url('search_repo',search_repo=c.repo_name),method='get')}

	%else:

		${h.form(h.url('search'),method='get')}

	%endif

	<div class="form">

		<div class="fields">

			<div class="field field-first field-noborder">

             <div class="label">

                 <label for="q">${_('Search term')}</label>

             </div>

				<div class="input">${h.text('q',c.cur_query,class_="small")}

					<div class="button highlight">

						<input type="submit" value="${_('Search')}" class="ui-button"/>

					</div>

				</div>

				<div style="font-weight: bold;clear:Both;margin-left:200px">${c.runtime}</div>

			</div>

			<div class="field">

	            <div class="label">

	                <label for="type">${_('Search in')}</label>

	            </div>

                <div class="select">

                    ${h.select('type',c.cur_type,[('content',_('File contents')),

                        ##('commit',_('Commit messages')),

                        ('path',_('File names')),

                        ##('repository',_('Repository names')),

                        ])}

                </div>

             </div>

		</div>

	</div>

	${h.end_form()}

    %if c.cur_search == 'content':

        <%include file='search_content.html'/>

    %elif c.cur_search == 'path':

        <%include file='search_path.html'/>

    %elif c.cur_search == 'commit':

        <%include file='search_commit.html'/>

    %elif c.cur_search == 'repository':

        <%include file='search_repository.html'/>

    %endif

</div>

</%def>