package PVE::API2::Cluster::Ceph;

use strict;
use warnings;

use JSON;

use PVE::Ceph::Services;
use PVE::Ceph::Tools;
use PVE::Cluster;
use PVE::Exception qw(raise_param_exc);
use PVE::JSONSchema qw(get_standard_option);
use PVE::RADOS;
use PVE::RESTHandler;
use PVE::SafeSyslog;
use PVE::Tools qw(extract_param);

use base qw(PVE::RESTHandler);

__PACKAGE__->register_method({
    name => 'cephindex',
    path => '',
    method => 'GET',
    description => "Cluster ceph index.",
    permissions => { user => 'all' },
    parameters => {
        additionalProperties => 0,
        properties => {},
    },
    returns => {
        type => 'array',
        items => {
            type => "object",
            properties => {},
        },
        links => [{ rel => 'child', href => "{name}" }],
    },
    code => sub {
        my ($param) = @_;

        my $result = [
            { name => 'metadata' }, { name => 'status' }, { name => 'flags' },
        ];

        return $result;
    },
});

my $metadata_common_props = {
    hostname => {
        type => "string",
        description => "Hostname on which the service is running.",
    },
    ceph_release => {
        type => "string",
        description => "Ceph release codename currently used.",
    },
    ceph_version => {
        type => "string",
        description => "Version info currently used by the service.",
    },
    ceph_version_short => {
        type => "string",
        description => "Short version (numerical) info currently used by the service.",
    },
    mem_total_kb => {
        type => "integer",
        description => "Memory consumption of the service.",
    },
    mem_swap_kb => {
        type => "integer",
        description => "Memory of the service currently in swap.",
    },
};

__PACKAGE__->register_method({
    name => 'metadata',
    path => 'metadata',
    method => 'GET',
    description => "Get ceph metadata.",
    protected => 1,
    permissions => {
        check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
    },
    parameters => {
        additionalProperties => 0,
        properties => {
            scope => {
                type => 'string',
                optional => 1,
                default => 'all',
                enum => ['all', 'versions'],
            },
        },
    },
    returns => {
        type => 'object',
        description => "Items for each type of service containing objects for each instance.",
        properties => {
            mds => {
                type => "object",
                description =>
                    "Metadata servers configured in the cluster and their properties.",
                properties => {
                    "{id}" => {
                        type => "object",
                        description => "Useful properties are listed, but not the full list.",
                        properties => {
                            addr => {
                                type => "string",
                                description => "Bind addresses and ports.",
                            },
                            name => {
                                type => "string",
                                description => "Name of the service instance.",
                            },
                            %{$metadata_common_props},
                        },
                    },
                },
            },
            mgr => {
                type => "object",
                description => "Managers configured in the cluster and their properties.",
                properties => {
                    "{id}" => {
                        type => "object",
                        description => "Useful properties are listed, but not the full list.",
                        properties => {
                            addr => {
                                type => "string",
                                description => "Bind address",
                            },
                            name => {
                                type => "string",
                                description => "Name of the service instance.",
                            },
                            %{$metadata_common_props},
                        },
                    },
                },
            },
            mon => {
                type => "object",
                description => "Monitors configured in the cluster and their properties.",
                properties => {
                    "{id}" => {
                        type => "object",
                        description => "Useful properties are listed, but not the full list.",
                        properties => {
                            addrs => {
                                type => "string",
                                description => "Bind addresses and ports.",
                            },
                            name => {
                                type => "string",
                                description => "Name of the service instance.",
                            },
                            %{$metadata_common_props},
                        },
                    },
                },
            },
            node => {
                type => "object",
                description => "Ceph version installed on the nodes.",
                properties => {
                    "{node}" => {
                        type => "object",
                        properties => {
                            buildcommit => {
                                type => "string",
                                description => "GIT commit used for the build.",
                            },
                            version => {
                                type => "object",
                                description => "Version info.",
                                properties => {
                                    str => {
                                        type => "string",
                                        description => "Version as single string.",
                                    },
                                    parts => {
                                        type => "array",
                                        description => "major, minor & patch",
                                    },
                                },
                            },
                        },
                    },
                },
            },
            osd => {
                type => "array",
                description => "OSDs configured in the cluster and their properties.",
                properties => {
                    "{id}" => {
                        type => "object",
                        description => "Useful properties are listed, but not the full list.",
                        properties => {
                            id => {
                                type => "integer",
                                description => "OSD ID.",
                            },
                            front_addr => {
                                type => "string",
                                description =>
                                    "Bind addresses and ports for frontend traffic to OSDs.",
                            },
                            back_addr => {
                                type => "string",
                                description =>
                                    "Bind addresses and ports for backend inter OSD traffic.",
                            },
                            device_id => {
                                type => "string",
                                description => "Devices used by the OSD.",
                            },
                            osd_data => {
                                type => "string",
                                description => "Path to the OSD data directory.",
                            },
                            osd_objectstore => {
                                type => "string",
                                description => "OSD objectstore type.",
                            },
                            %{$metadata_common_props},
                        },
                    },
                },
            },
        },
    },
    code => sub {
        my ($param) = @_;

        my $scope = $param->{scope} // 'all';

        my $res = {};

        if (defined(my $versions = PVE::Ceph::Services::get_ceph_versions())) {
            $res->{node} = $versions;
        }

        return $res if ($scope eq 'versions');

        # only check now, we want to allow calls with scope 'versions' on non-ceph nodes too!
        PVE::Ceph::Tools::check_ceph_inited();
        my $rados = PVE::RADOS->new();

        for my $type (qw(mon mgr mds)) {
            my $typedata = PVE::Ceph::Services::get_cluster_service($type);
            my $data = {};
            for my $host (sort keys %$typedata) {
                for my $service (sort keys %{ $typedata->{$host} }) {
                    $data->{"$service\@$host"} = $typedata->{$host}->{$service};
                }
            }

            # get data from metadata call and merge 'our' data
            my $services = $rados->mon_command({ prefix => "$type metadata" });
            for my $service (@$services) {
                my $hostname = $service->{hostname};
                next if !defined($hostname); # can happen if node is dead

                my $servicename = $service->{name} // $service->{id};
                my $id = "$servicename\@$hostname";

                if ($data->{$id}) { # copy values over to the metadata hash
                    for my $k (keys %{ $data->{$id} }) {
                        $service->{$k} = $data->{$id}->{$k};
                    }
                }
                $data->{$id} = $service;
            }

            $res->{$type} = $data;
        }

        $res->{osd} = $rados->mon_command({ prefix => "osd metadata" });

        return $res;
    },
});

__PACKAGE__->register_method({
    name => 'status',
    path => 'status',
    method => 'GET',
    description => "Get ceph status.",
    protected => 1,
    permissions => {
        check => ['perm', '/', ['Sys.Audit', 'Datastore.Audit'], any => 1],
    },
    parameters => {
        additionalProperties => 0,
        properties => {},
    },
    returns => { type => 'object' },
    code => sub {
        my ($param) = @_;

        PVE::Ceph::Tools::check_ceph_inited();

        return PVE::Ceph::Tools::ceph_cluster_status();
    },
});

my $possible_flags = PVE::Ceph::Tools::get_possible_osd_flags();
my $possible_flags_list = [sort keys %$possible_flags];

my $get_current_set_flags = sub {
    my $rados = shift;

    $rados //= PVE::RADOS->new();

    my $stat = $rados->mon_command({ prefix => 'osd dump' });
    my $setflags = $stat->{flags} // '';
    return { map { $_ => 1 } PVE::Tools::split_list($setflags) };
};

__PACKAGE__->register_method({
    name => 'get_all_flags',
    path => 'flags',
    method => 'GET',
    description => "get the status of all ceph flags",
    protected => 1,
    permissions => {
        check => ['perm', '/', ['Sys.Audit']],
    },
    parameters => {
        additionalProperties => 0,
        properties => {},
    },
    returns => {
        type => 'array',
        items => {
            type => "object",
            additionalProperties => 1,
            properties => {
                name => {
                    description => "Flag name.",
                    type => 'string',
                    enum => $possible_flags_list,
                },
                description => {
                    description => "Flag description.",
                    type => 'string',
                },
                value => {
                    description => "Flag value.",
                    type => 'boolean',
                },
            },
        },
        links => [{ rel => 'child', href => "{name}" }],
    },
    code => sub {
        my ($param) = @_;

        PVE::Ceph::Tools::check_ceph_configured();

        my $setflags = $get_current_set_flags->();

        my $res = [];
        foreach my $flag (@$possible_flags_list) {
            my $el = {
                name => $flag,
                description => $possible_flags->{$flag}->{description},
                value => 0,
            };

            my $realflag = PVE::Ceph::Tools::get_real_flag_name($flag);
            if ($setflags->{$realflag}) {
                $el->{value} = 1;
            }

            push @$res, $el;
        }

        return $res;
    },
});

__PACKAGE__->register_method({
    name => 'set_flags',
    path => 'flags',
    method => 'PUT',
    description => "Set/Unset multiple ceph flags at once.",
    protected => 1,
    permissions => {
        check => ['perm', '/', ['Sys.Modify']],
    },
    parameters => {
        additionalProperties => 0,
        properties => $possible_flags,
    },
    returns => { type => 'string' },
    code => sub {
        my ($param) = @_;

        my $rpcenv = PVE::RPCEnvironment::get();
        my $user = $rpcenv->get_user();
        PVE::Ceph::Tools::check_ceph_configured();

        my $worker = sub {
            my $rados = PVE::RADOS->new(); # (re-)open for forked worker

            my $setflags = $get_current_set_flags->($rados);

            my $errors = 0;
            foreach my $flag (@$possible_flags_list) {
                next if !defined($param->{$flag});
                my $val = $param->{$flag};
                my $realflag = PVE::Ceph::Tools::get_real_flag_name($flag);

                next if !$val == !$setflags->{$realflag}; # we do not set/unset flags to the same state

                my $prefix = $val ? 'set' : 'unset';
                eval {
                    print "$prefix $flag\n";
                    $rados->mon_command({ prefix => "osd $prefix", key => $flag });
                };
                if (my $err = $@) {
                    warn "error with $flag: '$err'\n";
                    $errors++;
                }
            }

            if ($errors) {
                die "could not set/unset $errors flags\n";
            }
        };

        return $rpcenv->fork_worker('cephsetflags', undef, $user, $worker);
    },
});

__PACKAGE__->register_method({
    name => 'get_flag',
    path => 'flags/{flag}',
    method => 'GET',
    description => "Get the status of a specific ceph flag.",
    protected => 1,
    permissions => {
        check => ['perm', '/', ['Sys.Audit']],
    },
    parameters => {
        additionalProperties => 0,
        properties => {
            flag => {
                description => "The name of the flag name to get.",
                type => 'string',
                enum => $possible_flags_list,
            },
        },
    },
    returns => {
        type => 'boolean',
    },
    code => sub {
        my ($param) = @_;

        PVE::Ceph::Tools::check_ceph_configured();

        my $realflag = PVE::Ceph::Tools::get_real_flag_name($param->{flag});

        my $setflags = $get_current_set_flags->();
        if ($setflags->{$realflag}) {
            return 1;
        }

        return 0;
    },
});

__PACKAGE__->register_method({
    name => 'update_flag',
    path => 'flags/{flag}',
    method => 'PUT',
    description => "Set or clear (unset) a specific ceph flag",
    protected => 1,
    permissions => {
        check => ['perm', '/', ['Sys.Modify']],
    },
    parameters => {
        additionalProperties => 0,
        properties => {
            flag => {
                description => 'The ceph flag to update',
                type => 'string',
                enum => $possible_flags_list,
            },
            value => {
                description => 'The new value of the flag',
                type => 'boolean',
            },
        },
    },
    returns => { type => 'null' },
    code => sub {
        my ($param) = @_;

        PVE::Ceph::Tools::check_ceph_configured();

        my $cmd = $param->{value} ? 'set' : 'unset';

        my $rados = PVE::RADOS->new();
        $rados->mon_command({
            prefix => "osd $cmd",
            key => $param->{flag},
        });

        return undef;
    },
});

1;