#!/usr/bin/perl

# This file is part of Koha.
#
# Koha 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.
#
# Koha 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 Koha; if not, see <https://www.gnu.org/licenses>.

use Modern::Perl;

use CGI qw ( -utf8 );
use Try::Tiny;

use C4::Context;
use C4::Auth   qw( get_template_and_user );
use C4::Output qw( output_html_with_http_headers );
use C4::ImportBatch;
use Koha::MarcOverlayRules;
use Koha::Patron::Categories;

my $input  = CGI->new;
my $op     = $input->param('op') || '';
my $errors = [];

my $rule_from_cgi = sub {
    my ($cgi) = @_;

    my %rule = map { $_ => scalar $cgi->param($_) } (
        'tag',
        'module',
        'filter',
        'add',
        'append',
        'remove',
        'delete'
    );

    my $id = $cgi->param('id');
    if ($id) {
        $rule{id} = $id;
    }

    return \%rule;
};

my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
    {
        template_name => "admin/marc-overlay-rules.tt",
        query         => $input,
        type          => "intranet",
        flagsrequired => { parameters => 'manage_marc_overlay_rules' },
    }
);

my $get_rules = sub {
    return Koha::MarcOverlayRules->search( undef, { order_by => { -asc => 'id' } } )->unblessed;
};
my $rules = $get_rules->();

if ( $op eq 'cud-remove' ) {
    my @remove_ids = $input->multi_param('batchremove');
    push @remove_ids, scalar $input->param('id') if $input->param('id');
    Koha::MarcOverlayRules->search( { id => { in => \@remove_ids } } )->delete();

    # Update $rules after deletion
    $rules = $get_rules->();
} elsif ( $op eq 'edit' ) {
    $template->param( edit => 1 );
    my $id = $input->param('id');
    for my $rule ( @{$rules} ) {
        if ( $rule->{id} == $id ) {
            $rule->{'edit'} = 1;
            last;
        }
    }
} elsif ( $op eq 'cud-edit' || $op eq 'cud-add' ) {
    my $rule_data = $rule_from_cgi->($input);
    if ( !@{$errors} ) {
        try {
            Koha::MarcOverlayRules->validate($rule_data);
        } catch {
            die $_ unless blessed $_ && $_->can('rethrow');

            if ( $_->isa('Koha::Exceptions::MarcOverlayRule::InvalidTagRegExp') ) {
                push @{$errors}, {
                    type => 'error',
                    code => 'invalid_tag_regexp',
                    tag  => $rule_data->{tag},
                };
            } elsif ( $_->isa('Koha::Exceptions::MarcOverlayRule::InvalidControlFieldActions') ) {
                push @{$errors}, {
                    type => 'error',
                    code => 'invalid_control_field_actions',
                    tag  => $rule_data->{tag},
                };
            } else {
                $_->rethrow;
            }
        };
        if ( !@{$errors} ) {
            my $rule = Koha::MarcOverlayRules->find_or_create($rule_data);

            # Need to call set and store here in case we have an update
            $rule->set($rule_data);
            $rule->store();
        }

        # Update $rules after edit/add
        $rules = $get_rules->();
    }
}

my $categories = Koha::Patron::Categories->search_with_library_limits(
    {},
    { order_by => ['description'], columns => [ 'categorycode', 'description' ] }
)->unblessed;

$template->param(
    rules      => $rules,
    categories => $categories,
    messages   => $errors
);

output_html_with_http_headers $input, $cookie, $template->output;
