package MT::Plugin::DivPages;
use strict;

use MT;
use MT::Template::Context;
use MT::Plugin;
use MT::Entry;
use CGI;

# show plugin information to main menu
eval("use Storable;");
if (!$@ && MT->can('add_plugin')) {
    my $plugin = MT::Plugin->new;
    $plugin->name('DivPages  1.01');
    $plugin->description('Divide pages that contain many entries.');
    MT->add_plugin($plugin);
}

# add tags
MT::Template::Context->add_tag(DivPagesInit => \&div_pages_init);
MT::Template::Context->add_container_tag(EntriesDivPages => \&entries_div_pages);

MT::Template::Context->add_tag(DivPagesCount => \&div_pages_count);
MT::Template::Context->add_conditional_tag(DivPagesIfMulti => \&div_pages_if_multi);
MT::Template::Context->add_tag(DivPagesEntryCount => \&div_pages_entry_count);

MT::Template::Context->add_tag(DivPagesCurPageNumber => \&div_pages_cur_page_number);
MT::Template::Context->add_tag(DivPagesCurPageFirstEntryNumber => \&div_pages_cur_page_first_entry_number);
MT::Template::Context->add_tag(DivPagesCurPageLastEntryNumber => \&div_pages_cur_page_last_entry_number);

MT::Template::Context->add_container_tag(DivPagesLoop => \&div_pages_loop);
MT::Template::Context->add_tag(DivPagesNumber => \&div_pages_number);
MT::Template::Context->add_tag(DivPagesLink => \&div_pages_link);
MT::Template::Context->add_tag(DivPagesFirstPageLink => \&div_pages_first_page_link);
MT::Template::Context->add_tag(DivPagesLastPageLink => \&div_pages_last_page_link);
MT::Template::Context->add_tag(DivPagesPrevPageLink => \&div_pages_prev_page_link);
MT::Template::Context->add_tag(DivPagesNextPageLink => \&div_pages_next_page_link);
MT::Template::Context->add_conditional_tag(DivPagesIfFirstPage => \&div_pages_if_first_page);
MT::Template::Context->add_conditional_tag(DivPagesIfLastPage => \&div_pages_if_last_page);
MT::Template::Context->add_conditional_tag(DivPagesIfPrevPage => \&div_pages_if_prev_page);
MT::Template::Context->add_conditional_tag(DivPagesIfNextPage => \&div_pages_if_next_page);

MT::Template::Context->add_conditional_tag(DivPagesIfDelimiter => \&div_pages_if_delimiter);
MT::Template::Context->add_conditional_tag(DivPagesIfCurPage => \&div_pages_if_cur_page);
MT::Template::Context->add_conditional_tag(DivPagesLoopHeader => \&div_pages_loop_header);
MT::Template::Context->add_conditional_tag(DivPagesLoopFooter => \&div_pages_loop_footer);

MT::Template::Context->add_tag(DivPagesCurPageLink => \&div_pages_cur_page_link);

# MTDivPagesInit tag
sub div_pages_init {
    my ($ctx, $args) = @_;

    # get "per_page" attribute
    my $per_page;
    $per_page = $args->{'per_page'} || 10;
    $ctx->stash('per_page', $per_page);

    # get entry count
    my $entry_count;
    if ($ctx->stash('entries')) {
        $entry_count = scalar @{$ctx->stash('entries')};
    }
    else {
        $entry_count = MT::Entry->count( { blog_id => $ctx->stash('blog')->id,
                                           status => MT::Entry::RELEASE() } );
    }
    $ctx->stash('entry_count', $entry_count);

    # set count of pages
    my $ec_tmp = $entry_count - 1;
    my $pages_count = ($ec_tmp - ($ec_tmp % $per_page)) / $per_page + 1;
    $ctx->stash('pages_count', $pages_count);

    # get "?page=x" parameter
    my $query = new CGI;
    my $cur_page_no = $query->param('page');
    if ($cur_page_no eq 'first') {
        $cur_page_no = 1;
    }
    elsif ($cur_page_no eq 'last') {
        $cur_page_no = $pages_count;
    }
    elsif ($cur_page_no < 1) {
        $cur_page_no = 1;
    }
    elsif ($cur_page_no > $pages_count) {
        $cur_page_no = $pages_count;
    }
    $cur_page_no = int($cur_page_no);
    $ctx->stash('cur_page_no', $cur_page_no);

    '';
}

# MTEntriesDivPages tag
sub entries_div_pages {
    my ($ctx, $args, $cond) = @_;

    my $cur_page_no  = $ctx->stash('cur_page_no');
    my $per_page = $ctx->stash('per_page');
    my $res = '';

    # get attributes
    my $lastn = $args->{'lastn'} || $per_page;
    my $offset = $args->{'offset'} + ($cur_page_no - 1) * $per_page;

    # load entries
#    my $offset = ($cur_page_no - 1) * $per_page;

    # out entries
    $args->{'offset'} = $offset;
    $args->{'lastn'} = $lastn;
    $res = $ctx->_hdlr_entries($args, $cond);
    $res;
}

# MTDivPagesLoop tag
sub div_pages_loop {
    my ($ctx, $args) = @_;

    my $tokens  = $ctx->stash('tokens');
    my $builder = $ctx->stash('builder');
    my $res = '';
    my @res;

    my ($pages_count, $cur_page_no, $delimiter);
    my ($ctr, $page_no, $all_flag, $first_pages, $mid_pages, $last_pages);
    my @page_numbers;

    $pages_count = $ctx->stash('pages_count');
    $all_flag    = $args->{'all'};
    $first_pages = $args->{'first'} || 0;
    $mid_pages   = $args->{'mid'} || 0;
    $last_pages  = $args->{'last'} || 0;
    $delimiter   = $args->{'delimiter'} || '';
    $cur_page_no = $ctx->stash('cur_page_no');
    $ctx->stash('number_delimiter', $delimiter);
    $all_flag = 1 if (!$first_pages && !$mid_pages && !$last_pages);

    # set page numbers
    if (!$all_flag) {
        push @page_numbers, 1 ... $first_pages if ($first_pages != 0);
        push @page_numbers, $cur_page_no - $mid_pages ... $cur_page_no + $mid_pages if ($mid_pages != 0);
        push @page_numbers, $pages_count - $last_pages + 1 ... $pages_count if ($last_pages != 0);
        my %temp_count;
        @page_numbers = grep(!$temp_count{$_}++, @page_numbers);
        @page_numbers = grep($_ <= $pages_count, @page_numbers);
        @page_numbers = grep($_ > 0, @page_numbers);
        @page_numbers = sort { $a <=> $b } @page_numbers;
    }
    else {
        push @page_numbers, 1 ... $pages_count;
    }

    # out page numbers
    $ctr = 0;
    foreach $page_no (@page_numbers) {
        $ctx->stash('loop_header', ($ctr == 0) ? 1 : 0);
        $ctx->stash('loop_footer', ($ctr == scalar(@page_numbers) - 1) ? 1 : 0);
        if ((($ctr == 0 && $page_numbers[$ctr] != 1) ||
             ($ctr != 0 && $page_numbers[$ctr - 1] != $page_numbers[$ctr] - 1))
            && $delimiter) {
            $ctx->stash('page_no', -1);
            defined(my $out = $builder->build($ctx, $tokens))
                or return $ctx->error($ctx->errstr);
            push @res, $out;
        }
        $ctx->stash('page_no', $page_no);
        defined(my $out = $builder->build($ctx, $tokens))
            or return $ctx->error($ctx->errstr);
        push @res, $out;
        if ($ctr == scalar(@page_numbers) - 1 &&
            $page_numbers[$ctr] != $ctx->stash('pages_count') &&
            $delimiter) {
            $ctx->stash('page_no', -1);
            defined(my $out = $builder->build($ctx, $tokens))
                or return $ctx->error($ctx->errstr);
            push @res, $out;
        }
        $ctr++;
    }
    my $glue = $args->{glue} || '';
    $res = join $glue, @res;
    $res;
}

# MTDivPagesEntryCount tag
sub div_pages_entry_count {
    my ($ctx, $args) = @_;

    $ctx->stash('entry_count');
}

# MTDivPagesNumber tag
sub div_pages_number {
    my ($ctx, $args) = @_;

    my $number = $ctx->stash('page_no');
    if ($number != -1) {
        return $number;
    }
    else {
        return $ctx->stash('number_delimiter');
    }
}

# MTDivPagesLink tag
sub div_pages_link {
    my ($ctx, $args) = @_;

    my $page_no = $ctx->stash('page_no');
    if ($page_no != -1) {
        return &div_pages_cur_page_link($ctx, $args) . "?page=$page_no";
    }
    else {
        return '';
    }
}

# MTDivPagesFirstPagelink tag
sub div_pages_first_page_link {
    my ($ctx, $args) = @_;

    &div_pages_cur_page_link($ctx, $args) . "?page=first";
}

# MTDivPagesLastPagelink tag
sub div_pages_last_page_link {
    my ($ctx, $args) = @_;

    &div_pages_cur_page_link($ctx, $args) . "?page=last";
}

# MTDivPagesPrevPagelink tag
sub div_pages_prev_page_link {
    my ($ctx, $args) = @_;

    my $cur_page_no = $ctx->stash('cur_page_no');
    &div_pages_cur_page_link($ctx, $args) . "?page=" . ($cur_page_no - 1);
}

# MTDivPagesNextPagelink tag
sub div_pages_next_page_link {
    my ($ctx, $args) = @_;

    my $cur_page_no = $ctx->stash('cur_page_no');
    &div_pages_cur_page_link($ctx, $args) . "?page=" . ($cur_page_no + 1);
}

# MTDivPagesIfFirstPage tag
sub div_pages_if_first_page {
    my ($ctx, $args) = @_;

    $ctx->stash('cur_page_no') == 1;
}

# MTDivPagesIfLastPage tag
sub div_pages_if_last_page {
    my ($ctx, $args) = @_;

    $ctx->stash('cur_page_no') == $ctx->stash('pages_count');
}

# MTDivPagesIfPrevPage tag
sub div_pages_if_prev_page {
    my ($ctx, $args) = @_;

    $ctx->stash('cur_page_no') > 1;
}

# MTDivPagesIfNextPage tag
sub div_pages_if_next_page {
    my ($ctx, $args) = @_;

    $ctx->stash('cur_page_no') < $ctx->stash('pages_count');
}

# MTDivPagesIfDelimiter tag
sub div_pages_if_delimiter {
    my ($ctx, $args) = @_;

    $ctx->stash('page_no') == -1;
}

# MTDivPagesIfCurPage tag
sub div_pages_if_cur_page {
    my ($ctx, $args) = @_;

    $ctx->stash('page_no') == $ctx->stash('cur_page_no');
}

# MTDivPagesCount tag
sub div_pages_count {
    my ($ctx, $args) = @_;

    $ctx->stash('pages_count');
}

# MTDivPagesIfMulti tag
sub div_pages_if_multi {
    my ($ctx, $args) = @_;

    $ctx->stash('pages_count') >= 2;
}

# MTDivPagesCurPageLink tag
sub div_pages_cur_page_link {
    my ($ctx, $args) = @_;

    my $mode = $args->{'mode'} || 'absolute';
    my $uri = $ctx->stash('cur_page_uri');
    if ($mode eq 'relative') {
        return $uri;
    }
    else {
        return 'http://' . $ENV{SERVER_NAME} . $uri;
    }
}

# MTDivPagesCurPageNumber tag
sub div_pages_cur_page_number {
    my ($ctx, $args) = @_;

    $ctx->stash('cur_page_no');
}

# MTDivPagesLoopHeader tag
sub div_pages_loop_header {
    my ($ctx, $args) = @_;

    $ctx->stash('loop_header');
}

# MTDivPagesLoopFooter tag
sub div_pages_loop_footer {
    my ($ctx, $args) = @_;

    $ctx->stash('loop_footer');
}

# MTDivPagesCurPageFirstEntryNumber tag
sub div_pages_cur_page_first_entry_number {
    my ($ctx, $args) = @_;

    my $cur_page = $ctx->stash('cur_page_no');
    my $per_page = $ctx->stash('per_page');
    ($cur_page - 1) * $per_page + 1;
}

# MTDivPagesCurPageLastEntryNumber tag
sub div_pages_cur_page_last_entry_number {
    my ($ctx, $args) = @_;

    my $cur_page = $ctx->stash('cur_page_no');
    my $per_page = $ctx->stash('per_page');
    if ($cur_page * $per_page > $ctx->stash('entry_count')) {
        return $ctx->stash('entry_count');
    }
    else {
        return $cur_page * $per_page;
    }
}