package PVE::AutoBalloon;

use warnings;
use strict;

sub compute_alg1 {
    my ($vmstatus, $goal, $maxchange, $debug) = @_;

    my $log = sub { print @_ if $debug; };

    my $change_func = sub {
        my ($res, $idlist, $bytes) = @_;

        my $rest = $bytes;
        my $repeat = 1;
        my $done_hash = {};
        my $progress = 1;

        while ($rest && $repeat && $progress) {
            $repeat = 0;
            $progress = 0;

            my $shares_total = 0;
            my $alloc_old = 0;

            foreach my $vmid (@$idlist) {
                next if defined($done_hash->{$vmid});
                my $d = $vmstatus->{$vmid};
                my $balloon = defined($res->{$vmid}) ? $res->{$vmid} : $d->{balloon};
                $alloc_old += $balloon - $d->{balloon_min};
                $shares_total += $d->{shares} || 1000;
            }

            my $changes = 0;

            my $alloc_new = $alloc_old + $rest;

            &$log("shares_total: $shares_total $alloc_new\n");

            foreach my $vmid (@$idlist) {
                next if defined($done_hash->{$vmid});
                my $d = $vmstatus->{$vmid};
                my $shares = $d->{shares} || 1000;
                my $desired = $d->{balloon_min} + int(($alloc_new / $shares_total) * $shares);

                if ($desired > $d->{maxmem}) {
                    $desired = $d->{maxmem};
                    $repeat = 1;
                } elsif ($desired < $d->{balloon_min}) {
                    $desired = $d->{balloon_min};
                    $repeat = 1;
                }

                my ($new, $balloon);
                if (($bytes > 0) && ($desired - $d->{balloon}) > 0) { # grow
                    $new = $d->{balloon} + $maxchange;
                    $balloon = $new > $desired ? $desired : $new;
                } elsif (($desired - $d->{balloon}) < 0) { # shrink
                    $new = $d->{balloon} - $maxchange;
                    $balloon = $new > $desired ? $new : $desired;
                } else {
                    $done_hash->{$vmid} = 1;
                    next;
                }

                my $diff = $balloon - $d->{balloon};
                if ($diff != 0) {
                    my $oldballoon = defined($res->{$vmid}) ? $res->{$vmid} : $d->{balloon};
                    $res->{$vmid} = $balloon;
                    my $change = $balloon - $oldballoon;
                    if ($change != 0) {
                        $changes += $change;
                        my $absdiff = $diff > 0 ? $diff : -$diff;
                        $progress += $absdiff;
                        $repeat = 1;
                    }
                    &$log(
                        "change request for $vmid ($balloon, $diff, $desired, $new, $changes, $progress)\n"
                    );
                }
            }

            $rest -= $changes;
        }

        return $rest;
    };

    my $idlist = []; # list of VMs with working balloon river
    my $idlist1 = []; # list of VMs with memory pressure
    my $idlist2 = []; # list of VMs with enough free memory

    foreach my $vmid (keys %$vmstatus) {
        my $d = $vmstatus->{$vmid};
        next if !$d->{balloon}; # skip if balloon driver not running
        next if !$d->{balloon_min}; # skip if balloon value not set in config
        next if $d->{lock} && $d->{lock} eq 'migrate';
        next
            if defined($d->{shares})
            && ($d->{shares} == 0); # skip if shares set to zero

        push @$idlist, $vmid;

        if (
            $d->{freemem}
            && ($d->{freemem} > $d->{balloon_min} * 0.25)
            && ($d->{balloon} >= $d->{balloon_min})
        ) {
            push @$idlist2, $vmid;
            &$log("idlist2 $vmid $d->{balloon}, $d->{balloon_min}, $d->{freemem}\n");
        } else {
            push @$idlist1, $vmid;
            &$log("idlist1 $vmid $d->{balloon}, $d->{balloon_min}\n");
        }
    }

    my $res = {};

    if ($goal > 10 * 1024 * 1024) {
        &$log("grow request start $goal\n");
        # priorize VMs with memory pressure
        my $rest = &$change_func($res, $idlist1, $goal);
        if ($rest >= $goal) { # no progress ==> consider all VMs
            &$log("grow request loop $rest\n");
            $rest = &$change_func($res, $idlist, $rest);
        }
        &$log("grow request end $rest\n");

    } elsif ($goal < -10 * 1024 * 1024) {
        &$log("shrink request $goal\n");
        # priorize VMs with enough free memory
        my $rest = &$change_func($res, $idlist2, $goal);
        if ($rest <= $goal) { # no progress ==> consider all VMs
            &$log("shrink request loop $rest\n");
            $rest = &$change_func($res, $idlist, $rest);
        }
        &$log("shrink request end $rest\n");
    } else {
        &$log("do nothing\n");
        # do nothing - requested change to small
    }

    foreach my $vmid (@$idlist) {
        next if !$res->{$vmid};
        my $d = $vmstatus->{$vmid};
        my $diff = int($res->{$vmid} - $d->{balloon});
        my $absdiff = $diff < 0 ? -$diff : $diff;
        &$log("BALLOON $vmid to $res->{$vmid} ($diff)\n");
    }
    return $res;
}

1;