# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.

package Bugzilla::Template::Plugin::Hook;

use 5.10.1;
use strict;

use base qw(Template::Plugin);

use Bugzilla::Constants;
use Bugzilla::Install::Util qw(template_include_path); 
use Bugzilla::Util;
use Bugzilla::Error;

use File::Spec;

sub new {
    my ($class, $context) = @_;
    return bless { _CONTEXT => $context }, $class;
}

sub _context { return $_[0]->{_CONTEXT} }

sub process {
    my ($self, $hook_name, $template) = @_;
    my $context = $self->_context();
    $template ||= $context->stash->{component}->{name};

    # sanity check:
    if (!$template =~ /[\w\.\/\-_\\]+/) {
        ThrowCodeError('template_invalid', { name => $template });
    }

    my (undef, $path, $filename) = File::Spec->splitpath($template);
    $path ||= '';
    $filename =~ m/(.+)\.(.+)\.tmpl$/;
    my $template_name = $1;
    my $type = $2;

    # Hooks are named like this:
    my $extension_template = "$path$template_name-$hook_name.$type.tmpl";

    # Get the hooks out of the cache if they exist. Otherwise, read them
    # from the disk.
    my $cache = Bugzilla->request_cache->{template_plugin_hook_cache} ||= {};
    my $lang = $context->{bz_language} || '';
    $cache->{"${lang}__$extension_template"} 
        ||= $self->_get_hooks($extension_template);

    # process() accepts an arrayref of templates, so we just pass the whole
    # arrayref.
    $context->{bz_in_hook} = 1; # See Bugzilla::Template::Context
    return $context->process($cache->{"${lang}__$extension_template"});
}

sub _get_hooks {
    my ($self, $extension_template) = @_;

    my $template_sets = $self->_template_hook_include_path();
    my @hooks;
    foreach my $dir_set (@$template_sets) {
        foreach my $template_dir (@$dir_set) {
            my $file = "$template_dir/hook/$extension_template";
            if (-e $file) {
                my $template = $self->_context->template($file);
                push(@hooks, $template);
                # Don't run the hook for more than one language.
                last;
            }
        }
    }

    return \@hooks;
}

sub _template_hook_include_path {
    my $self = shift;
    my $cache = Bugzilla->request_cache;
    my $language = $self->_context->{bz_language} || '';
    my $cache_key = "template_plugin_hook_include_path_$language";
    $cache->{$cache_key} ||= template_include_path({
        language => $language,
        hook     => 1,
    });
    return $cache->{$cache_key};
}

1;

__END__

=head1 NAME

Bugzilla::Template::Plugin::Hook

=head1 DESCRIPTION

Template Toolkit plugin to process hooks added into templates by extensions.

=head1 METHODS

=over

=item B<process>

=over

=item B<Description>

Processes hooks added into templates by extensions.

=item B<Params>

=over

=item C<hook_name>

The unique name of the template hook.

=item C<template> (optional)

The path of the calling template.
This is used as a work around to a bug which causes the path to the hook
to be incorrect when the hook is called from inside a block.

Example: If the hook C<lastrow> is added to the template
F<show-multiple.html.tmpl> and it is desired to force the correct template
path, the template hook would be:

 [% Hook.process("lastrow", "bug/show-multiple.html.tmpl") %]

=back

=item B<Returns> 

Output from processing template extension.

=back

=back

=head1 SEE ALSO

L<Template::Plugin>

L<http://wiki.mozilla.org/Bugzilla:Writing_Extensions>