package MT::App::SearchPN;
## ----------------------------------------------------------------------------
# MT::App::SearchPN
# - ver 0.02
#     bug-fix : MT::Entry->count で status=>2 を追加。
#
# - ver 0.01
# - MT::App::Search のページ処理版。plugin で実装したかったけど断念。ダサイ実装になってしまった・・・
#   まだ、_new_comments検索には未対応
#   MT::ObjectDriver::DBI::mysql は regex 句対応版にオーバーライド
# 
# Author: drk <drk at drk7.jp>
# License: same as Perl
## ----------------------------------------------------------------------------

use strict;

use File::Spec;
use MT::Util qw( encode_html );

use constant TEMP_TABLE => 'temp_Table';
use MT::App;
use MT::ConfigMgr;
use POSIX;
@MT::App::SearchPN::ISA = qw( MT::App );

our $imported = 0;

## ----------------------------------------------------------------------------
## MT::ObjectDriver::DBI::mysql をオーバーライド。regexp 句に対応
## ----------------------------------------------------------------------------
sub _import {
    my $app = shift;

#	return if($imported);
#	$imported=1;

	no strict 'refs';

	my $mysqlsuper = MT::ObjectDriver::DBI::mysql->can('_prepare_from_where');
	*{"MT::ObjectDriver::DBI::mysql::_prepare_from_where"} = sub {
	    my($driver, $class, $terms, $args) = @_;

	    my($tbl, $sql, $bind) = &$mysqlsuper(@_);
	    return ($tbl, $sql, $bind) unless(defined $args->{regexp});
#print STDERR "$tbl\n$sql:",join(',',@$bind),"\n";

	    my @w_terms = sort keys %{$args->{regexp}};
	    my @w_bind  = map{ @{$args->{regexp}->{$_}} } @w_terms;

	    ## where 句があるとき
	    if ($sql=~/^(.+where.+?\n)(.*)$/ims) {
	        my $cond = join(' and ', @w_terms) . "\n";
	        $sql = "$1 and $cond $2";
	        push @$bind, @w_bind;
	    ## where 句がないとき
	    } elsif ($sql=~/^(.+from.+?\n)(.*)$/ims) {
	        my $cond = "where " . join(' and ', @w_terms) . "\n";
	        $sql = "$1 $cond $2";
	        push @$bind, @w_bind;
	    }
#print STDERR "->$tbl\n$sql:",join(',',@$bind),"\n";
	    return ($tbl, $sql, $bind);
    };
}



## ----------------------------------------------------------------------------
## MT::App::SearchPN::init
## 変更点：$app->{search_page}, $app->{search_limit} 追加
## ----------------------------------------------------------------------------
sub init {
    my $app = shift;
    $app->SUPER::init(@_) or return;
    $app->add_methods( search => \&execute );
    $app->{default_mode} = 'search';
    $app->{user_class} = 'MT::Author';
    $app->{charset} = $app->{cfg}->PublishCharset;

    my $q = $app->{query};
    my $cfg = $app->{cfg};

    ## Check whether IP address has searched in the last
    ## minute which is still progressing. If so, block it.
    if (eval { require DB_File; 1 }) {
        my $file = File::Spec->catfile($cfg->TempDir, 'mt-throttle.db');
        my $DB = tie my %db, 'DB_File', $file;
        if ($DB) {
            my $ip = $app->remote_ip;
            if (my $time = $db{$ip}) {
                if ($time > time - 10) {   ## Within the last minute.
                    return $app->error($app->translate(
                        "You are currently performing a search. Please wait " .
                        "until your search is completed."));
                }
            }
            $db{$ip} = time;
            undef $DB;
            untie %db;
            $app->{__have_throttle} = 1;
        }
    }

    my %no_override = map { $_ => 1 } split /\s*,\s*/, $cfg->NoOverride;

    ## Combine user-selected included/excluded blogs
    ## with config file settings.
    for my $type (qw( IncludeBlogs ExcludeBlogs )) {
        $app->{searchparam}{$type} = { };
        if (my $list = $cfg->$type()) {
            $app->{searchparam}{$type} =
                { map { $_ => 1 } split /\s*,\s*/, $list };
        }
        next if $no_override{$type};
        for my $blog_id ($q->param($type)) {
            $app->{searchparam}{$type}{$blog_id} = 1;
        }
    }

    ## If IncludeBlogs has not been set, we need to build a list of
    ## the blogs to search. If ExcludeBlogs was set, exclude any blogs
    ## set in that list from our final list.
    if (!keys %{ $app->{searchparam}{IncludeBlogs} }) {
        my $exclude = $app->{searchparam}{ExcludeBlogs};
        require MT::Blog;
        my $iter = MT::Blog->load_iter;
        while (my $blog = $iter->()) {
            $app->{searchparam}{IncludeBlogs}{$blog->id} = 1
                unless $exclude && $exclude->{$blog->id};
        }
    }

    ## Set other search params--prefer per-query setting, default to
    ## config file.
    for my $key (qw( RegexSearch CaseSearch ResultDisplay SearchCutoff
                     CommentSearchCutoff ExcerptWords SearchElement
                     Type MaxResults SearchSortBy )) {
        $app->{searchparam}{$key} = $no_override{$key} ?
            $cfg->$key() : ($q->param($key) || $cfg->$key());
    }
    $app->{searchparam}{Template} = $q->param('Template') ||
        ($app->{searchparam}{Type} eq 'newcomments' ? 'comments' : 'default');

    ## Define alternate user templates from config file
    if (my @tmpls = $cfg->AltTemplate) {
        for my $tmpl (@tmpls) {
            my($nickname, $file) = split /\s+/, $tmpl;
            $app->{templates}{$nickname} = $file;
	}
    }
    $app->{templates}{default} = $cfg->DefaultTemplate;
    $app->{searchparam}{SearchTemplatePath} = $cfg->SearchTemplatePath;

    ## Set search_string (for display only)
    if ($app->{searchparam}{Type} eq 'straight') {
        $app->{search_string} = $q->param('search') || '';
    }

    ## Get login information if user is logged in (via cookie).
    ## If no login cookie, this fails silently, and that's fine.
    ($app->{user}) = $app->login;

    $app;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::DESTROY
## 変更点：なし
## ----------------------------------------------------------------------------
sub DESTROY {
    my $app = shift;
    if ($app->{__have_throttle}) {
        my $file = File::Spec->catfile(MT::ConfigMgr->instance()->TempDir,
                                       'mt-throttle.db');
        if (tie my %db, 'DB_File', $file) {
            delete $db{$app->remote_ip};
            untie %db;
        }
    }
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::execute
## 変更点：$ctx->stash に 'results_total', 'search_page', 'search_limit' 追加
## ----------------------------------------------------------------------------
sub execute {
    my $app = shift;
	$app->_import();

	## added by drk 05.12.10 paginate search results /
	$app->{search_string}= $app->{query}->param('search') || '';
	$app->{search_page}  = $app->{query}->param('page') || 0;	## page number
	$app->{search_limit} = $app->{query}->param('limit') || 10;	## limit
	delete $app->{results_total};
	## / added by drk 05.12.10 paginate search results

    my @results;
    if ($app->{searchparam}{Type} eq 'newcomments') {
        $app->_new_comments
            or return $app->error($app->translate(
                "Search failed: [_1]", $app->errstr));
        @results = $app->{results} ? @{ $app->{results} } : ();
    } else {
        $app->_straight_search
            or return $app->error($app->translate(
                "Search failed: [_1]", $app->errstr));
        ## Results are stored per-blog, so we sort the list of blogs by name,
        ## then add in the results to the final list.
        my $col = $app->{searchparam}{SearchSortBy};
        my $order = $app->{searchparam}{ResultDisplay} || 'ascend';
        for my $blog (sort keys %{ $app->{results} }) {
            my @res = @{ $app->{results}{$blog} };
            if ($col) {
                @res = $order eq 'ascend' ?
                  sort { $a->{entry}->$col() cmp $b->{entry}->$col() } @res :
                  sort { $b->{entry}->$col() cmp $a->{entry}->$col() } @res;
            }
            $res[0]{blogheader} = 1;
            push @results, @res;
        }
    }

    ## We need to put a blog in context so that includes and <$MTBlog*$>
    ## tags will work, if they are used. So we choose the first blog in
    ## the result list. If there is no result list, just load the first
    ## blog from the database.
    my($blog);
    if (@results) {
        $blog = $results[0]{blog};
    }
    unless ($blog) {
        my $include = $app->{searchparam}{IncludeBlogs};
        if ($include && keys(%$include) == 1) {
            $blog = MT::Blog->load((keys %$include)[0]);
        } else {
            $blog = MT::Blog->load;
        }
    }

    ## Initialize and set up the context object.
    my $ctx = MT::App::SearchPN::Context->new;
    $ctx->stash('blog', $blog);
    $ctx->stash('blog_id', $blog->id);
    $ctx->stash('results', \@results);
    $ctx->stash('user', $app->{user});
    if (my $str = $app->{search_string}) {
        $ctx->stash('search_string', encode_html($str));
    }

	## added by drk 05.12.10 paginate search results /
    $ctx->stash('results_total', $app->{results_total}{$blog->name});
    $ctx->stash('search_page',   $app->{search_page});
    $ctx->stash('search_limit',  $app->{search_limit});
	## / added by drk 05.12.10 paginate search results

    ## Load the search template.
    my $tmpl_file = $app->{templates}{ $app->{searchparam}{Template} }
        or return $app->error($app->translate("No alternate template is specified for the " .
                              "Template '[_1]'", $app->{searchparam}{Template}));
    my $tmpl = File::Spec->catfile($app->{searchparam}{SearchTemplatePath},
        $tmpl_file);
    local *FH;
    open FH, $tmpl
        or return $app->error($app->translate(
            "Opening local file '[_1]' failed: [_2]", $tmpl, "$!" ));
    my $str;
    { local $/; $str = <FH> };
    close FH;

#    $app->set_language($blog->language);
#    $str = $app->l10n_filter($str);
    $str = MT->translate_templatized($str);

    ## Compile and build the search template with results.
    require MT::Builder;
    my $build = MT::Builder->new;
    my $tokens = $build->compile($ctx, $str)
        or return $app->error($app->translate(
            "Building results failed: [_1]", $build->errstr));
    defined(my $res = $build->build($ctx, $tokens, { 
        NoSearch => $app->{query}->param('help') ||
                    ($app->{searchparam}{Type} ne 'newcomments' &&
                      (!$ctx->stash('search_string') ||
                      $ctx->stash('search_string') !~ /\S/)) ? 1 : 0,
        NoSearchResults => $ctx->stash('search_string') &&
                           $ctx->stash('search_string') =~ /\S/ &&
                           !scalar @results,
        SearchResults => scalar @results,
        } ))
        or return $app->error($app->translate(
            "Building results failed: [_1]", $build->errstr));
    $app->_set_form_elements($res);
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::_straight_search
## 変更点：ページ処理いろいろ追加
## ----------------------------------------------------------------------------
sub _straight_search {
    my $app = shift;
    return 1 unless $app->{search_string} =~ /\S/;

    $app->log($app->translate("Search: query for '[_1]'", $app->{search_string}));

    ## Parse, tokenize and optimize the search query.
    $app->query_parse;

	## added by drk 05.12.10 paginate search results /
    my $mgr = MT::ConfigMgr->instance;
    my $regexpcond = '';
    my @regexpval;
    if($mgr->ObjectDriver eq 'DBI::mysql') {
		map {
			my $type = $_->{type};
			my $atom = $_->{atom};
			   $atom=~ s/\?://g;
			push @regexpval, ($atom,$atom);
			$regexpcond .= ' and ' if($regexpcond);
			if($type eq 'AND') {
				$regexpcond .= '(entry_text regexp ? or entry_text_more regexp ?)';
			} else {
				$regexpcond .= '(entry_text not regexp ? and entry_text_more not regexp ?)';
			}
		} @{$app->{searchparam}{search_keys}};
	}
	## / added by drk 05.12.10 paginate search results

    ## Load available blogs and iterate through entries looking for search term
    require MT::Util;
    require MT::Blog;
    require MT::Entry;
    my %terms = (status => MT::Entry::RELEASE());
    my %args = (direction => $app->{searchparam}{ResultDisplay},
                'sort' => 'created_on');
	## added by drk 05.12.10 paginate search results /
    if($mgr->ObjectDriver eq 'DBI::mysql') {
        $args{'limit'}  = $app->{search_limit};
        $args{'offset'} = $app->{search_limit}*$app->{search_page};
        $args{'regexp'} = { $regexpcond => [@regexpval] };
    }
	## / added by drk 05.12.10 paginate search results
    if ($app->{searchparam}{SearchCutoff} &&
        $app->{searchparam}{SearchCutoff} != 9999999) {
        my @ago = MT::Util::offset_time_list(time - 3600 * 24 *
                  $app->{searchparam}{SearchCutoff});
        my $ago = sprintf "%04d%02d%02d%02d%02d%02d",
            $ago[5]+1900, $ago[4]+1, @ago[3,2,1,0];
        $terms{created_on} = [ $ago ];
        $args{range} = { created_on => 1 };
    }

    my $iter = MT::Entry->load_iter(\%terms, \%args);
    my(%blogs, %hits);
    my $max = $app->{searchparam}{MaxResults}; 
    my $include = $app->{searchparam}{IncludeBlogs};
	my %tmp_blog;	## added by drk 05.12.10 paginate search results
    while (my $entry = $iter->()) {
        my $blog_id = $entry->blog_id;
        next unless $include->{$blog_id};
        next if $hits{$blog_id} && $hits{$blog_id} >= $max;
        if ($app->_search_hit($entry)) {
            my $blog = $blogs{$blog_id} || MT::Blog->load($blog_id);
            $app->_store_hit_data($blog, $entry, $hits{$blog_id}++);
			$tmp_blog{$blog->id} = $blog unless($tmp_blog{$blog->id});	## added by drk 05.12.10 paginate search results
        }
    }

	## added by drk 05.12.10 paginate search results /
    return 1 unless($mgr->ObjectDriver eq 'DBI::mysql');
	map{
		my $blog = $tmp_blog{$_};
		$app->{results_total}{$blog->name} = 
			MT::Entry->count({blog_id => $blog->id, status => 2,},,{
               	'regexp'   => { $regexpcond => [@regexpval] },
			});
	} keys %tmp_blog;
	## / added by drk 05.12.10 paginate search results

    1;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::_new_comments
## 変更点：なし
## ----------------------------------------------------------------------------
sub _new_comments {
    my $app = shift;
    return 1 if $app->{query}->param('help');

    $app->log($app->translate("Search: new comment search"));
    require MT::Entry;
    require MT::Blog;
    require MT::Util;
    my %args = ('join' => [
                    'MT::Comment', 'entry_id', {},
                    { 'sort' => 'created_on',
                       direction => 'descend',
                       unique => 1, }
               ]);
    if ($app->{searchparam}{CommentSearchCutoff} &&
        $app->{searchparam}{CommentSearchCutoff} != 9999999) {
        my @ago = MT::Util::offset_time_list(time - 3600 * 24 *
                  $app->{searchparam}{CommentSearchCutoff});
        my $ago = sprintf "%04d%02d%02d%02d%02d%02d",
            $ago[5]+1900, $ago[4]+1, @ago[3,2,1,0];
        $args{'join'}->[2]{created_on} = [ $ago ];
        $args{'join'}->[3]{range} = { created_on => 1 };
    } elsif ($app->{searchparam}{MaxResults} &&
             $app->{searchparam}{MaxResults} != 9999999) {
        $args{limit} = $app->{searchparam}{MaxResults};
    }
    my $iter = MT::Entry->load_iter({ status => MT::Entry::RELEASE() }, \%args);
    my %blogs;
    my $include = $app->{searchparam}{IncludeBlogs};
    while (my $entry = $iter->()) {
        next unless $include->{ $entry->blog_id };
        my $blog = $blogs{ $entry->blog_id } || MT::Blog->load($entry->blog_id);
        $app->_store_hit_data($blog, $entry);
    }
    1;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::_set_form_elements
## 変更点：なし
## ----------------------------------------------------------------------------
sub _set_form_elements {
    my($app, $tmpl) = @_;
    ## Fill in user-defined template with proper form settings.
    if ($app->{searchparam}{Type} eq 'newcomments') {
        if ($app->{searchparam}{CommentSearchCutoff}) {
            $tmpl =~ s/(<select name="CommentSearchCutoff">.*<option value="$app->{searchparam}{CommentSearchCutoff}")/$1 selected="selected"/si;
        } else {
            $tmpl =~ s/(<select name="CommentSearchCutoff">.*<option value="9999999")/$1 selected="selected"/si;
        }
    } else {
        if ($app->{searchparam}{SearchCutoff}) {
            $tmpl =~ s/(<select name="SearchCutoff">.*<option value="$app->{searchparam}{SearchCutoff}")/$1 selected="selected"/si;
        } else {
            $tmpl =~ s/(<select name="SearchCutoff">.*<option value="9999999")/$1 selected="selected"/si;
        }

        if ($app->{searchparam}{CaseSearch}) {
            $tmpl =~ s/(<input type="checkbox"[^>]+name="CaseSearch")/$1 checked="checked"/g;
        }
        if ($app->{searchparam}{RegexSearch}) {
            $tmpl =~ s/(<input type="checkbox"[^>]+name="RegexSearch")/$1 checked="checked"/g;
        }
        $tmpl =~ s/(<input type="radio"[^>]+?$app->{searchparam}{SearchElement}\")/$1 checked="checked"/g;
        for my $type (qw( IncludeBlogs ExcludeBlogs )) {
            for my $blog_id (keys %{ $app->{searchparam}{$type} }) {
                $tmpl =~ s/(<input type="checkbox"[^>]+?$type" value="$blog_id")/$1 checked="checked"/g;    #"
            }
        }
    }
    if ($app->{searchparam}{MaxResults}) {
        $tmpl =~ s/(<select name="MaxResults">.*<option value="$app->{searchparam}{MaxResults}")/$1 selected="selected"/si;
    } else {
        $tmpl =~ s/(<select name="MaxResults">.*<option value="9999999")/$1 selected="selected"/si;
    }
    $tmpl;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::is_a_match
## 変更点：なし
## ----------------------------------------------------------------------------
sub is_a_match { 
    my($app, $txt) = @_;
    if ($app->{searchparam}{RegexSearch}) {
        eval {m/$app->{search_string}/;};
        return if (my $err = $@);
        return unless $txt =~ m/$app->{search_string}/;
    } else {
        my $casemod = $app->{searchparam}{CaseSearch} ? '' : '(?i)';
        for (@{$app->{searchparam}{search_keys}{AND}}) {
            return unless $txt =~ /$casemod$_/;
	}
	for (@{$app->{searchparam}{search_keys}{NOT}}) {
            return if $txt =~ /$casemod$_/;
        }
    }
    1;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::query_parse
## 変更点：search_keys->{atoms} は quotemeta しない
## ----------------------------------------------------------------------------
sub query_parse {
    my $app = shift;
    return unless $app->{search_string};

    local $_ = $app->{search_string};
    s/^\s//;            # Remove leading whitespace
    s/\s$//;            # Remove trailing whitespace
    s/\s+AND\s+/ /g;    # Remove AND because it's implied
    s/\s{2,}/ /g;       # Remove contiguous spaces

    my @search_keys;
    my @tokens = split;

	## added by drk 05.12.10 paginate search results
    my $mgr = MT::ConfigMgr->instance;
	## added by drk 05.12.10 paginate search results

    while (my $atom = shift @tokens) {
        my($type);
        if ($atom eq 'NOT' || $atom eq 'AND') {
            $type = $atom;
            $atom = shift @tokens;
            $atom = find_phrase($atom, \@tokens) if $atom =~ /^\"/;
        } elsif ($atom eq 'OR') {
            $atom = shift @tokens;
            $atom = find_phrase($atom, \@tokens) if $atom =~ /^\"/;
            ## OR new atom with last atom
            $search_keys[-1]{atom} =
                '(?:' . $search_keys[-1]{atom} .'|' . quotemeta($atom) . ')';
            next;
        } elsif ($atom =~ /^-(.*)/) {
            $type = 'NOT';
            $atom = $1;
            $atom = find_phrase($atom, \@tokens) if $atom =~ /^\"/;
        } else {
            $type = 'AND';
            $atom = find_phrase($atom, \@tokens) if $atom =~ /^\"/;
        }

        ## changed by drk 05.12.10 un-quotemeta for SQL-cond.
#       push @search_keys, { atom => quotemeta($atom),
        push @search_keys, { atom => ($mgr->ObjectDriver eq 'DBI::mysql') ? $atom : quotemeta($atom),
                             type => $type };
    }

    $app->{searchparam}{search_keys} = \@search_keys;
    $app->query_optimize;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::find_phrase
## 変更点：なし
## ----------------------------------------------------------------------------
sub find_phrase {
    my($atom, $tokenref) = @_;
    while (my $next = shift @$tokenref) {
	$atom = $atom . ' ' . $next;
        last if $atom =~ /\"$/;
    }
    $atom =~ s/^"(.*)"$/$1/;
    $atom;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::query_optimize
## 変更点：なし
## ----------------------------------------------------------------------------
sub query_optimize {
    my $app = shift;
	return $app->{searchparam}{search_keys};

    ## Sort keys longest to shortest for search efficiency.
    $app->{searchparam}{search_keys} = [
        reverse sort { length($a->{atom}) <=> length($b->{atom}) }
        @{ $app->{searchparam}{search_keys} }
    ];
    
    ## Sort keys by contents. Any ORs immediately get a lower priority.
    my %terms;
    for my $key (@{ $app->{searchparam}{search_keys} }) {
        if ($key->{atom} =~ /\(.*\|.*\)/) {
            push(@{ $terms{$key->{type}}{low} }, $key);
        } else {
            push(@{ $terms{$key->{type}}{high} }, $key);
        }
    }

    ## Final priority: AND long, AND short, AND with OR (long/short),
    ## NOT long/short
    ##  This should give us the most efficient search in that it is
    ##  searching for the harder-to-match keys first.
    my %regex;
    for my $type (qw( AND NOT )) {
        for my $pri (qw( high low )) {
            for my $obj (@{ $terms{$type}{$pri} }) {
                push(@{ $regex{$type} }, $obj->{atom});
            }
        }
    }

    $app->{searchparam}{search_keys} = \%regex;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::_search_hit
## 変更点：mysql の場合は SQL レベルでマッチング済みなのでなにもしない
## ----------------------------------------------------------------------------
sub _search_hit {
    my($app, $entry) = @_;

    ## added by drk 05.12.10 paginate search results
    my $mgr = MT::ConfigMgr->instance;
    return 1 if($mgr->ObjectDriver eq 'DBI::mysql');
    ## added by drk 05.12.10 paginate search results

    my @text_elements;
    if ($app->{searchparam}{SearchElement} ne 'comments') {
        @text_elements = ($entry->title, $entry->text, $entry->text_more,
                          $entry->keywords);
    }
    if ($app->{searchparam}{SearchElement} ne 'entries') {
        my $comments = $entry->comments;
        for my $comment (@$comments) {
            push @text_elements, $comment->text, $comment->author,
                                 $comment->url;
        }
    }
    return 1 if $app->is_a_match(join("\n", map $_ || '', @text_elements));
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::_store_hit_data
## 変更点：なし
## ----------------------------------------------------------------------------
sub _store_hit_data {
    my $app = shift;
    my($blog, $entry, $banner_seen) = @_;
    my %result_data = (blog => $blog);
    ## Need to create entry excerpt here, because we can't rely on
    ## the user's per-blog setting.
    unless ($entry->excerpt) {
        $entry->excerpt($entry->get_excerpt($app->{searchparam}{ExcerptWords}));
    }
    $result_data{entry} = $entry;
    if ($app->{searchparam}{Type} eq 'newcomments') {
        push @{ $app->{results} }, \%result_data;
    } else {
        push(@{ $app->{results}{ $blog->name } }, \%result_data);
    }
}


package MT::App::SearchPN::Context;
use MT::Template::Context;
@MT::App::SearchPN::Context::ISA = qw( MT::Template::Context );

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::init
## 変更点：$ctx->register_handler 追加
##         - SearchResultsTotal, SearchResultsFirstIdx, SearchResultsLastIdx, SearchNavigation
## ----------------------------------------------------------------------------
sub init {
    my $ctx = shift;
    $ctx->SUPER::init(@_);
    $ctx->register_handler(EntryEditLink => \&_hdlr_entry_edit_link);
    $ctx->register_handler(SearchResults => [ \&_hdlr_results, 1 ]);
    $ctx->register_handler(SearchResultCount => \&_hdlr_result_count);
    $ctx->register_handler(SearchString => \&_hdlr_search_string);
    $ctx->register_handler(NoSearchResults =>
        [ \&MT::Template::Context::_hdlr_pass_tokens, 1 ]);
    $ctx->register_handler(NoSearch =>
        [ \&MT::Template::Context::_hdlr_pass_tokens, 1 ]);
    $ctx->register_handler(BlogResultHeader =>
        [ \&MT::Template::Context::_hdlr_pass_tokens, 1 ]);
    $ctx->register_handler(BlogResultFooter =>
        [ \&MT::Template::Context::_hdlr_pass_tokens, 1 ]);

    ## added by drk 05.12.10 paginate search results
    $ctx->register_handler(SearchResultsTotal    => \&_hdlr_results_total);
    $ctx->register_handler(SearchResultsFirstIdx => \&_hdlr_results_firstidx);
    $ctx->register_handler(SearchResultsLastIdx  => \&_hdlr_results_lastidx);
    $ctx->register_handler(SearchNavigation      => \&_hdlr_results_navigation);

    $ctx;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_results_total
## 変更点：新規
## ----------------------------------------------------------------------------
sub _hdlr_results_total { $_[0]->stash('results_total') || 0 }

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_results_firstidx
## 変更点：新規
## ----------------------------------------------------------------------------
sub _hdlr_results_firstidx {
    my $total = $_[0]->stash('results_total')||0;
    my $page  = $_[0]->stash('search_page')||0;
    my $limit = $_[0]->stash('search_limit')||10;
    return $page*$limit+1;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_results_lastidx
## 変更点：新規
## ----------------------------------------------------------------------------
sub _hdlr_results_lastidx {
    my $total = $_[0]->stash('results_total')||0;
    my $page  = $_[0]->stash('search_page')||0;
    my $limit = $_[0]->stash('search_limit')||10;
    return $total<(1+$page)*$limit ? $total : (1+$page)*$limit;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_results_navigation
## 変更点：新規
## ----------------------------------------------------------------------------
sub _hdlr_results_navigation {
    my $total = $_[0]->stash('results_total')||0;
    my $page  = $_[0]->stash('search_page')||0;
    my $limit = $_[0]->stash('search_limit')||10;
    my $word  = $_[0]->stash('search_string')||'';
       $word  = MT::Util::encode_url($word);
    my $maxpage = POSIX::ceil($total/$limit);
    my $output= '';
    my $cgi = MT::ConfigMgr->instance->SearchScript;
    for(my $i=0; $i<$maxpage; $i++) {
        my $idx = $i+1;
        my $str = ($i==$page) ? "<b>[$idx]</b>" : $idx;
        $output.=qq{&nbsp;<a href="$cgi?search=$word&page=$i&limit=$limit">$str</a>&nbsp;};
        $output.='<br />' if($i>0 && $i%30==0);
    }
    $output;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_search_string
## 変更点：なし
## ----------------------------------------------------------------------------
sub _hdlr_search_string { $_[0]->stash('search_string') || '' }

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_result_count
## 変更点：なし
## ----------------------------------------------------------------------------
sub _hdlr_result_count {
    my $results = $_[0]->stash('results');
    $results && ref($results) eq 'ARRAY' ? scalar @$results : 0;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_results
## 変更点：なし
## ----------------------------------------------------------------------------
sub _hdlr_results {
    my($ctx, $args) = @_;
    ## If there are no results, return the empty string, knowing
    ## that the handler for <MTNoSearchResults> will fill in the
    ## no results message.
    my $results = $ctx->stash('results') or return '';

    my $output = '';
    my $build = $ctx->stash('builder');
    my $tokens = $ctx->stash('tokens');
    for my $res (@$results) {
        $ctx->stash('entry', $res->{entry});
        local $ctx->{__stash}{blog} = $res->{blog};
        $ctx->stash('result', $res);
        local $ctx->{current_timestamp} = $res->{entry}->created_on;
        defined(my $out = $build->build($ctx, $tokens,
            { BlogResultHeader => $res->{blogheader} ? 1 : 0 }
            )) or return $ctx->error( $build->errstr );
        $output .= $out;
    }
    $output;
}

## ----------------------------------------------------------------------------
## MT::App::SearchPN::Context::_hdlr_entry_edit_link
## 変更点：なし
## ----------------------------------------------------------------------------
sub _hdlr_entry_edit_link {   
    my($ctx, $args) = @_;
    my $user = $ctx->stash('user') or return '';
    my $entry = $ctx->stash('entry')
        or return $ctx->error(MT->translate(
            'You used an [_1] tag outside of the proper context.',
            '<$MTEntryEditLink$>' ));
    my $blog_id = $entry->blog_id;
    my $cfg = MT::ConfigMgr->instance;
    my $url = $cfg->AdminCGIPath || $cfg->CGIPath;
    $url .= '/' unless $url =~ m!/$!;
    require MT::Permission;
    my $perms = MT::Permission->load({ author_id => $user->id,
                                       blog_id => $blog_id });
    return '' unless $perms && $perms->can_edit_entry($entry, $user);
    my $app = MT->instance;
    sprintf
      q([<a href="%s%s%s">Edit</a>]),
      $url, $cfg->AdminScript, $app->uri_params('mode' => 'view', args => { '_type' => 'entry', id => $entry->id, blog_id => $blog_id});
}

1;