package PVE::API2::Cluster::Notifications;

use warnings;
use strict;

use Storable qw(dclone);
use JSON;

use PVE::Exception qw(raise_param_exc);
use PVE::Tools qw(extract_param);
use PVE::JSONSchema qw(get_standard_option);
use PVE::RESTHandler;
use PVE::Notify;

use base qw(PVE::RESTHandler);

sub make_properties_optional {
    my ($properties) = @_;
    $properties = dclone($properties);

    for my $key (keys %$properties) {
	$properties->{$key}->{optional} = 1 if $key ne 'name';
    }

    return $properties;
}

sub remove_protected_properties {
    my ($properties, $to_remove) = @_;
    $properties = dclone($properties);

    for my $key (keys %$properties) {
	if (grep /^$key$/, @$to_remove) {
	    delete $properties->{$key};
	}
    }

    return $properties;
}

sub raise_api_error {
    my ($api_error) = @_;

    if (!(ref($api_error) eq 'HASH' && $api_error->{message} && $api_error->{code})) {
	die $api_error;
    }

    my $msg = "$api_error->{message}\n";
    my $exc = PVE::Exception->new($msg, code => $api_error->{code});

    my (undef, $filename, $line) = caller;

    $exc->{filename} = $filename;
    $exc->{line} = $line;

    die $exc;
}

__PACKAGE__->register_method ({
    name => 'index',
    path => '',
    method => 'GET',
    description => 'Index for notification-related API endpoints.',
    permissions => { user => 'all' },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {},
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $result = [
	    { name => 'endpoints' },
	    { name => 'matchers' },
	    { name => 'targets' },
	    { name => 'matcher-fields' },
	    { name => 'matcher-field-values' },
	];

	return $result;
    }
});

__PACKAGE__->register_method ({
    name => 'get_matcher_fields',
    path => 'matcher-fields',
    method => 'GET',
    description => 'Returns known notification metadata fields',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    protected => 0,
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		name => {
		    description => 'Name of the field.',
		    type => 'string',
		},
	    },
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	# TODO: Adapt this API handler once we have a 'notification registry'

	my $result = [
	    { name => 'type' },
	    { name => 'hostname' },
	    { name => 'job-id' },
	];

	return $result;
    }
});

__PACKAGE__->register_method ({
    name => 'get_matcher_field_values',
    path => 'matcher-field-values',
    method => 'GET',
    description => 'Returns known notification metadata fields and their known values',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    protected => 1,
    parameters => {
	additionalProperties => 0,
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		'value' => {
		    description => 'Notification metadata value known by the system.',
		    type => 'string'
		},
		'comment' => {
		    description => 'Additional comment for this value.',
		    type => 'string',
		    optional => 1,
		},
		'field' => {
		    description => 'Field this value belongs to.',
		    type => 'string',
		},
	    },
	},
    },
    code => sub {
	# TODO: Adapt this API handler once we have a 'notification registry'
	my $rpcenv = PVE::RPCEnvironment::get();
	my $user = $rpcenv->get_user();

	my $values = [
	    {
		value => 'package-updates',
		field => 'type',
	    },
	    {
		value => 'fencing',
		field => 'type',
	    },
	    {
		value => 'replication',
		field => 'type',
	    },
	    {
		value => 'vzdump',
		field => 'type',
	    },
	    {
		value => 'system-mail',
		field => 'type',
	    },
	];

	# Here we need a manual permission check.
	if ($rpcenv->check($user, "/", ["Sys.Audit"], 1)) {
	    for my $backup_job (@{PVE::API2::Backup->index({})}) {
		push @$values, {
		    value => $backup_job->{id},
		    comment => $backup_job->{comment},
		    field => 'job-id'
		};
	    }
	}
	# The API call returns only returns jobs for which the user
	# has adequate permissions.
	for my $sync_job (@{PVE::API2::ReplicationConfig->index({})}) {
	    push @$values, {
		value => $sync_job->{id},
		comment => $sync_job->{comment},
		field => 'job-id'
	    };
	}

	for my $node (@{PVE::Cluster::get_nodelist()}) {
	    push @$values, {
		value => $node,
		field => 'hostname',
	    }
	}

	return $values;
    }
});

__PACKAGE__->register_method ({
    name => 'endpoints_index',
    path => 'endpoints',
    method => 'GET',
    description => 'Index for all available endpoint types.',
    permissions => { user => 'all' },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {},
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $result = [
	    { name => 'gotify' },
	    { name => 'sendmail' },
	    { name => 'smtp' },
	    { name => 'webhook' },
	];

	return $result;
    }
});

__PACKAGE__->register_method ({
    name => 'get_all_targets',
    path => 'targets',
    method => 'GET',
    description => 'Returns a list of all entities that can be used as notification targets.',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	    ['perm', '/mapping/notifications', ['Mapping.Use']],
	],
    },
    protected => 1,
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		name => {
		    description => 'Name of the target.',
		    type => 'string',
		    format => 'pve-configid',
		},
		'type' => {
		    description => 'Type of the target.',
		    type  => 'string',
		    enum => [qw(sendmail gotify smtp webhook)],
		},
		'comment' => {
		    description => 'Comment',
		    type => 'string',
		    optional => 1,
		},
		'disable' => {
		    description => 'Show if this target is disabled',
		    type => 'boolean',
		    optional => 1,
		    default => 0,
		},
		'origin' => {
		    description => 'Show if this entry was created by a user or was built-in',
		    type  => 'string',
		    enum => [qw(user-created builtin modified-builtin)],
		},
	    },
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $config = PVE::Notify::read_config();

	my $targets = eval {
	    $config->get_targets();
	};

	raise_api_error($@) if $@;

	return $targets;
    }
});

__PACKAGE__->register_method ({
    name => 'test_target',
    path => 'targets/{name}/test',
    protected => 1,
    method => 'POST',
    description => 'Send a test notification to a provided target.',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	    ['perm', '/mapping/notifications', ['Mapping.Use']],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		description => 'Name of the target.',
		type => 'string',
		format => 'pve-configid'
	    },
	},
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	eval {
	    my $config = PVE::Notify::read_config();
	    $config->test_target($name);
	};

	raise_api_error($@) if $@;

	return;
    }
});

my $sendmail_properties = {
    name => {
	description => 'The name of the endpoint.',
	type => 'string',
	format => 'pve-configid',
    },
    mailto => {
	type => 'array',
	items => {
	    type => 'string',
	    format => 'email-or-username',
	},
	description => 'List of email recipients',
	optional => 1,
    },
    'mailto-user' => {
	type => 'array',
	items => {
	    type => 'string',
	    format => 'pve-userid',
	},
	description => 'List of users',
	optional => 1,
    },
    'from-address' => {
	description => '`From` address for the mail',
	type => 'string',
	optional => 1,
    },
    author => {
	description => 'Author of the mail',
	type => 'string',
	optional => 1,
    },
    'comment' => {
	description => 'Comment',
	type => 'string',
	optional => 1,
    },
    'disable' => {
	description => 'Disable this target',
	type => 'boolean',
	optional => 1,
	default => 0,
    },
};

__PACKAGE__->register_method ({
    name => 'get_sendmail_endpoints',
    path => 'endpoints/sendmail',
    method => 'GET',
    description => 'Returns a list of all sendmail endpoints',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    protected => 1,
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		%$sendmail_properties,
		'origin' => {
		    description => 'Show if this entry was created by a user or was built-in',
		    type  => 'string',
		    enum => [qw(user-created builtin modified-builtin)],
		},
	    },
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $config = PVE::Notify::read_config();

	my $entities = eval {
	    $config->get_sendmail_endpoints();
	};
	raise_api_error($@) if $@;

	return $entities;
    }
});

__PACKAGE__->register_method ({
    name => 'get_sendmail_endpoint',
    path => 'endpoints/sendmail/{name}',
    method => 'GET',
    description => 'Return a specific sendmail endpoint',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    protected => 1,
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => {
	type => 'object',
	properties => {
	    %$sendmail_properties,
	    digest => get_standard_option('pve-config-digest'),
	}

    },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	my $config = PVE::Notify::read_config();
	my $endpoint = eval {
	    $config->get_sendmail_endpoint($name)
	};

	raise_api_error($@) if $@;
	$endpoint->{digest} = $config->digest();

	return $endpoint;
    }
});

__PACKAGE__->register_method ({
    name => 'create_sendmail_endpoint',
    path => 'endpoints/sendmail',
    protected => 1,
    method => 'POST',
    description => 'Create a new sendmail endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => $sendmail_properties,
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $mailto = extract_param($param, 'mailto');
	my $mailto_user = extract_param($param, 'mailto-user');
	my $from_address = extract_param($param, 'from-address');
	my $author = extract_param($param, 'author');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->add_sendmail_endpoint(
		    $name,
		    $mailto,
		    $mailto_user,
		    $from_address,
		    $author,
		    $comment,
		    $disable,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'update_sendmail_endpoint',
    path => 'endpoints/sendmail/{name}',
    protected => 1,
    method => 'PUT',
    description => 'Update existing sendmail endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    %{ make_properties_optional($sendmail_properties) },
	    delete => {
		type => 'array',
		items => {
		    type => 'string',
		    format => 'pve-configid',
		},
		optional => 1,
		description => 'A list of settings you want to delete.',
	    },
	    digest => get_standard_option('pve-config-digest'),

	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $mailto = extract_param($param, 'mailto');
	my $mailto_user = extract_param($param, 'mailto-user');
	my $from_address = extract_param($param, 'from-address');
	my $author = extract_param($param, 'author');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	my $delete = extract_param($param, 'delete');
	my $digest = extract_param($param, 'digest');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->update_sendmail_endpoint(
		    $name,
		    $mailto,
		    $mailto_user,
		    $from_address,
		    $author,
		    $comment,
		    $disable,
		    $delete,
		    $digest,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'delete_sendmail_endpoint',
    protected => 1,
    path => 'endpoints/sendmail/{name}',
    method => 'DELETE',
    description => 'Remove sendmail endpoint',
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();
		$config->delete_sendmail_endpoint($name);
		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if ($@);
	return;
    }
});

my $gotify_properties = {
    name => {
	description => 'The name of the endpoint.',
	type => 'string',
	format => 'pve-configid',
    },
    'server' => {
	description => 'Server URL',
	type => 'string',
    },
    'token' => {
	description => 'Secret token',
	type => 'string',
    },
    'comment' => {
	description => 'Comment',
	type => 'string',
	optional => 1,
    },
    'disable' => {
	description => 'Disable this target',
	type => 'boolean',
	optional => 1,
	default => 0,
    },
};

__PACKAGE__->register_method ({
    name => 'get_gotify_endpoints',
    path => 'endpoints/gotify',
    method => 'GET',
    description => 'Returns a list of all gotify endpoints',
    protected => 1,
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
	check => ['perm', '/mapping/notifications', ['Mapping.Audit']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		% {remove_protected_properties($gotify_properties, ['token'])},
		'origin' => {
		    description => 'Show if this entry was created by a user or was built-in',
		    type  => 'string',
		    enum => [qw(user-created builtin modified-builtin)],
		},
	    },
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $config = PVE::Notify::read_config();
	my $rpcenv = PVE::RPCEnvironment::get();

	my $entities = eval {
	    $config->get_gotify_endpoints();
	};
	raise_api_error($@) if $@;

	return $entities;
    }
});

__PACKAGE__->register_method ({
    name => 'get_gotify_endpoint',
    path => 'endpoints/gotify/{name}',
    method => 'GET',
    description => 'Return a specific gotify endpoint',
    protected => 1,
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
		description => 'Name of the endpoint.'
	    },
	}
    },
    returns => {
	type => 'object',
	properties => {
	    %{ remove_protected_properties($gotify_properties, ['token']) },
	    digest => get_standard_option('pve-config-digest'),
	}
    },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	my $config = PVE::Notify::read_config();
	my $endpoint = eval {
	    $config->get_gotify_endpoint($name)
	};

	raise_api_error($@) if $@;
	$endpoint->{digest} = $config->digest();

	return $endpoint;
    }
});

__PACKAGE__->register_method ({
    name => 'create_gotify_endpoint',
    path => 'endpoints/gotify',
    protected => 1,
    method => 'POST',
    description => 'Create a new gotify endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => $gotify_properties,
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $server = extract_param($param, 'server');
	my $token = extract_param($param, 'token');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->add_gotify_endpoint(
		    $name,
		    $server,
		    $token,
		    $comment,
		    $disable,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'update_gotify_endpoint',
    path => 'endpoints/gotify/{name}',
    protected => 1,
    method => 'PUT',
    description => 'Update existing gotify endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    %{ make_properties_optional($gotify_properties) },
	    delete => {
		type => 'array',
		items => {
		    type => 'string',
		    format => 'pve-configid',
		},
		optional => 1,
		description => 'A list of settings you want to delete.',
	    },
	    digest => get_standard_option('pve-config-digest'),
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $server = extract_param($param, 'server');
	my $token = extract_param($param, 'token');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	my $delete = extract_param($param, 'delete');
	my $digest = extract_param($param, 'digest');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->update_gotify_endpoint(
		    $name,
		    $server,
		    $token,
		    $comment,
		    $disable,
		    $delete,
		    $digest,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'delete_gotify_endpoint',
    protected => 1,
    path => 'endpoints/gotify/{name}',
    method => 'DELETE',
    description => 'Remove gotify endpoint',
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();
		$config->delete_gotify_endpoint($name);
		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

my $smtp_properties= {
    name => {
	description => 'The name of the endpoint.',
	type => 'string',
	format => 'pve-configid',
    },
    server => {
	description => 'The address of the SMTP server.',
	type => 'string',
    },
    port => {
	description => 'The port to be used. Defaults to 465 for TLS based connections,'
	    . ' 587 for STARTTLS based connections and port 25 for insecure plain-text'
	    . ' connections.',
	type => 'integer',
	optional => 1,
    },
    mode => {
	description => 'Determine which encryption method shall be used for the connection.',
	type => 'string',
	enum => [ qw(insecure starttls tls) ],
	default => 'tls',
	optional => 1,
    },
    username => {
	description => 'Username for SMTP authentication',
	type => 'string',
	optional => 1,
    },
    password => {
	description => 'Password for SMTP authentication',
	type => 'string',
	optional => 1,
    },
    mailto => {
	type => 'array',
	items => {
	    type => 'string',
	    format => 'email-or-username',
	},
	description => 'List of email recipients',
	optional => 1,
    },
    'mailto-user' => {
	type => 'array',
	items => {
	    type => 'string',
	    format => 'pve-userid',
	},
	description => 'List of users',
	optional => 1,
    },
    'from-address' => {
	description => '`From` address for the mail',
	type => 'string',
    },
    author => {
	description => 'Author of the mail. Defaults to \'Proxmox VE\'.',
	type => 'string',
	optional => 1,
    },
    'comment' => {
	description => 'Comment',
	type => 'string',
	optional => 1,
    },
    'disable' => {
	description => 'Disable this target',
	type => 'boolean',
	optional => 1,
	default => 0,
    },
};

__PACKAGE__->register_method ({
    name => 'get_smtp_endpoints',
    path => 'endpoints/smtp',
    method => 'GET',
    description => 'Returns a list of all smtp endpoints',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    protected => 1,
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		%{ remove_protected_properties($smtp_properties, ['password']) },
		'origin' => {
		    description => 'Show if this entry was created by a user or was built-in',
		    type  => 'string',
		    enum => [qw(user-created builtin modified-builtin)],
		},
	    },
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $config = PVE::Notify::read_config();

	my $entities = eval {
	    $config->get_smtp_endpoints();
	};
	raise_api_error($@) if $@;

	return $entities;
    }
});

__PACKAGE__->register_method ({
    name => 'get_smtp_endpoint',
    path => 'endpoints/smtp/{name}',
    method => 'GET',
    description => 'Return a specific smtp endpoint',
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    protected => 1,
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => {
	type => 'object',
	properties => {
	    %{ remove_protected_properties($smtp_properties, ['password']) },
	    digest => get_standard_option('pve-config-digest'),
	}

    },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	my $config = PVE::Notify::read_config();
	my $endpoint = eval {
	    $config->get_smtp_endpoint($name)
	};

	raise_api_error($@) if $@;
	$endpoint->{digest} = $config->digest();

	return $endpoint;
    }
});

__PACKAGE__->register_method ({
    name => 'create_smtp_endpoint',
    path => 'endpoints/smtp',
    protected => 1,
    method => 'POST',
    description => 'Create a new smtp endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => $smtp_properties,
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $server = extract_param($param, 'server');
	my $port = extract_param($param, 'port');
	my $mode = extract_param($param, 'mode');
	my $username = extract_param($param, 'username');
	my $password = extract_param($param, 'password');
	my $mailto = extract_param($param, 'mailto');
	my $mailto_user = extract_param($param, 'mailto-user');
	my $from_address = extract_param($param, 'from-address');
	my $author = extract_param($param, 'author');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->add_smtp_endpoint(
		    $name,
		    $server,
		    $port,
		    $mode,
		    $username,
		    $password,
		    $mailto,
		    $mailto_user,
		    $from_address,
		    $author,
		    $comment,
		    $disable,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'update_smtp_endpoint',
    path => 'endpoints/smtp/{name}',
    protected => 1,
    method => 'PUT',
    description => 'Update existing smtp endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    %{ make_properties_optional($smtp_properties) },
	    delete => {
		type => 'array',
		items => {
		    type => 'string',
		    format => 'pve-configid',
		},
		optional => 1,
		description => 'A list of settings you want to delete.',
	    },
	    digest => get_standard_option('pve-config-digest'),

	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $server = extract_param($param, 'server');
	my $port = extract_param($param, 'port');
	my $mode = extract_param($param, 'mode');
	my $username = extract_param($param, 'username');
	my $password = extract_param($param, 'password');
	my $mailto = extract_param($param, 'mailto');
	my $mailto_user = extract_param($param, 'mailto-user');
	my $from_address = extract_param($param, 'from-address');
	my $author = extract_param($param, 'author');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	my $delete = extract_param($param, 'delete');
	my $digest = extract_param($param, 'digest');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->update_smtp_endpoint(
		    $name,
		    $server,
		    $port,
		    $mode,
		    $username,
		    $password,
		    $mailto,
		    $mailto_user,
		    $from_address,
		    $author,
		    $comment,
		    $disable,
		    $delete,
		    $digest,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'delete_smtp_endpoint',
    protected => 1,
    path => 'endpoints/smtp/{name}',
    method => 'DELETE',
    description => 'Remove smtp endpoint',
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();
		$config->delete_smtp_endpoint($name);
		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if ($@);
	return;
    }
});

my $webhook_properties = {
    name => {
	description => 'The name of the endpoint.',
	type => 'string',
	format => 'pve-configid',
    },
    url => {
	description => 'Server URL',
	type => 'string',
    },
    method => {
	description => 'HTTP method',
	type => 'string',
	enum => [qw(post put get)],
    },
    header => {
	description => 'HTTP headers to set. These have to be formatted as'
	  . ' a property string in the format name=<name>,value=<base64 of value>',
	type => 'array',
	items => {
	    type => 'string',
	},
	optional => 1,
    },
    body => {
	description => 'HTTP body, base64 encoded',
	type => 'string',
	optional => 1,
    },
    secret => {
	description => 'Secrets to set. These have to be formatted as'
	  . ' a property string in the format name=<name>,value=<base64 of value>',
	type => 'array',
	items => {
	    type => 'string',
	},
	optional => 1,
    },
    comment => {
	description => 'Comment',
	type => 'string',
	optional => 1,
    },
    disable => {
	description => 'Disable this target',
	type => 'boolean',
	optional => 1,
	default => 0,
    },
};

__PACKAGE__->register_method ({
    name => 'get_webhook_endpoints',
    path => 'endpoints/webhook',
    method => 'GET',
    description => 'Returns a list of all webhook endpoints',
    protected => 1,
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
	check => ['perm', '/mapping/notifications', ['Mapping.Audit']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		%$webhook_properties,
		'origin' => {
		    description => 'Show if this entry was created by a user or was built-in',
		    type  => 'string',
		    enum => [qw(user-created builtin modified-builtin)],
		},
	    },
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $config = PVE::Notify::read_config();
	my $rpcenv = PVE::RPCEnvironment::get();

	my $entities = eval {
	    $config->get_webhook_endpoints();
	};
	raise_api_error($@) if $@;

	return $entities;
    }
});

__PACKAGE__->register_method ({
    name => 'get_webhook_endpoint',
    path => 'endpoints/webhook/{name}',
    method => 'GET',
    description => 'Return a specific webhook endpoint',
    protected => 1,
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
		description => 'Name of the endpoint.'
	    },
	}
    },
    returns => {
	type => 'object',
	properties => {
	    %$webhook_properties,
	    digest => get_standard_option('pve-config-digest'),
	}
    },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	my $config = PVE::Notify::read_config();
	my $endpoint = eval {
	    $config->get_webhook_endpoint($name)
	};

	raise_api_error($@) if $@;
	$endpoint->{digest} = $config->digest();

	return $endpoint;
    }
});

__PACKAGE__->register_method ({
    name => 'create_webhook_endpoint',
    path => 'endpoints/webhook',
    protected => 1,
    method => 'POST',
    description => 'Create a new webhook endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => $webhook_properties,
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->add_webhook_endpoint(
		    $param,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'update_webhook_endpoint',
    path => 'endpoints/webhook/{name}',
    protected => 1,
    method => 'PUT',
    description => 'Update existing webhook endpoint',
    permissions => {
	check => ['and',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['or',
		['perm', '/', [ 'Sys.Audit', 'Sys.Modify' ]],
		['perm', '/', [ 'Sys.AccessNetwork' ]],
	    ],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    %{ make_properties_optional($webhook_properties) },
	    delete => {
		type => 'array',
		items => {
		    type => 'string',
		    format => 'pve-configid',
		},
		optional => 1,
		description => 'A list of settings you want to delete.',
	    },
	    digest => get_standard_option('pve-config-digest'),
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $delete = extract_param($param, 'delete');
	my $digest = extract_param($param, 'digest');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->update_webhook_endpoint(
		    $name,
		    $param,                # Config updater
		    $delete,
		    $digest,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'delete_webhook_endpoint',
    protected => 1,
    path => 'endpoints/webhook/{name}',
    method => 'DELETE',
    description => 'Remove webhook endpoint',
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();
		$config->delete_webhook_endpoint($name);
		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

my $matcher_properties = {
    name => {
	description => 'Name of the matcher.',
	type => 'string',
	format => 'pve-configid',
    },
    'match-field' => {
	type => 'array',
	items => {
	    type => 'string',
	},
	optional => 1,
	description => 'Metadata fields to match (regex or exact match).'
	    . ' Must be in the form (regex|exact):<field>=<value>',
    },
    'match-severity' => {
	type => 'array',
	items => {
	    type => 'string',
	},
	optional => 1,
	description => 'Notification severities to match',
    },
    'match-calendar' => {
	type => 'array',
	items => {
	    type => 'string',
	},
	optional => 1,
	description => 'Match notification timestamp',
    },
    'target' => {
	type => 'array',
	items => {
	    type => 'string',
	    format => 'pve-configid',
	},
	optional => 1,
	description => 'Targets to notify on match',
    },
    mode => {
	type => 'string',
	description => "Choose between 'all' and 'any' for when multiple properties are specified",
	optional => 1,
	enum => [qw(all any)],
	default => 'all',
    },
    'invert-match' => {
	type => 'boolean',
	description => 'Invert match of the whole matcher',
	optional => 1,
    },
    'comment' => {
	description => 'Comment',
	type => 'string',
	optional => 1,
    },
    'disable' => {
	description => 'Disable this matcher',
	type => 'boolean',
	optional => 1,
	default => 0,
    },
};

__PACKAGE__->register_method ({
    name => 'get_matchers',
    path => 'matchers',
    method => 'GET',
    description => 'Returns a list of all matchers',
    protected => 1,
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	    ['perm', '/mapping/notifications', ['Mapping.Use']],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {},
    },
    returns => {
	type => 'array',
	items => {
	    type => 'object',
	    properties => {
		%$matcher_properties,
		'origin' => {
		    description => 'Show if this entry was created by a user or was built-in',
		    type  => 'string',
		    enum => [qw(user-created builtin modified-builtin)],
		},
	    }
	},
	links => [ { rel => 'child', href => '{name}' } ],
    },
    code => sub {
	my $config = PVE::Notify::read_config();

	my $entities = eval {
	    $config->get_matchers();
	};
	raise_api_error($@) if $@;

	return $entities;
    }
});

__PACKAGE__->register_method ({
    name => 'get_matcher',
    path => 'matchers/{name}',
    method => 'GET',
    description => 'Return a specific matcher',
    protected => 1,
    permissions => {
	check => ['or',
	    ['perm', '/mapping/notifications', ['Mapping.Modify']],
	    ['perm', '/mapping/notifications', ['Mapping.Audit']],
	],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => {
	type => 'object',
	properties => {
	    %$matcher_properties,
	    digest => get_standard_option('pve-config-digest'),
	},
    },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	my $config = PVE::Notify::read_config();

	my $matcher = eval {
	    $config->get_matcher($name)
	};

	raise_api_error($@) if $@;
	$matcher->{digest} = $config->digest();

	return $matcher;
    }
});

__PACKAGE__->register_method ({
    name => 'create_matcher',
    path => 'matchers',
    protected => 1,
    method => 'POST',
    description => 'Create a new matcher',
    protected => 1,
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => $matcher_properties,
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $match_severity = extract_param($param, 'match-severity');
	my $match_field = extract_param($param, 'match-field');
	my $match_calendar = extract_param($param, 'match-calendar');
	my $target = extract_param($param, 'target');
	my $mode = extract_param($param, 'mode');
	my $invert_match = extract_param($param, 'invert-match');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->add_matcher(
		    $name,
		    $target,
		    $match_severity,
		    $match_field,
		    $match_calendar,
		    $mode,
		    $invert_match,
		    $comment,
		    $disable,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'update_matcher',
    path => 'matchers/{name}',
    protected => 1,
    method => 'PUT',
    description => 'Update existing matcher',
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    %{ make_properties_optional($matcher_properties) },
	    delete => {
		type => 'array',
		items => {
		    type => 'string',
		    format => 'pve-configid',
		},
		optional => 1,
		description => 'A list of settings you want to delete.',
	    },
	    digest => get_standard_option('pve-config-digest'),
	},
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $name = extract_param($param, 'name');
	my $match_severity = extract_param($param, 'match-severity');
	my $match_field = extract_param($param, 'match-field');
	my $match_calendar = extract_param($param, 'match-calendar');
	my $target = extract_param($param, 'target');
	my $mode = extract_param($param, 'mode');
	my $invert_match = extract_param($param, 'invert-match');
	my $comment = extract_param($param, 'comment');
	my $disable = extract_param($param, 'disable');
	my $digest = extract_param($param, 'digest');
	my $delete = extract_param($param, 'delete');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();

		$config->update_matcher(
		    $name,
		    $target,
		    $match_severity,
		    $match_field,
		    $match_calendar,
		    $mode,
		    $invert_match,
		    $comment,
		    $disable,
		    $delete,
		    $digest,
		);

		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

__PACKAGE__->register_method ({
    name => 'delete_matcher',
    protected => 1,
    path => 'matchers/{name}',
    method => 'DELETE',
    description => 'Remove matcher',
    permissions => {
	check => ['perm', '/mapping/notifications', ['Mapping.Modify']],
    },
    parameters => {
	additionalProperties => 0,
	properties => {
	    name => {
		type => 'string',
		format => 'pve-configid',
	    },
	}
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;
	my $name = extract_param($param, 'name');

	eval {
	    PVE::Notify::lock_config(sub {
		my $config = PVE::Notify::read_config();
		$config->delete_matcher($name);
		PVE::Notify::write_config($config);
	    });
	};

	raise_api_error($@) if $@;
	return;
    }
});

1;