<?php

namespace CpChart;

use Exception;

/**
 * This class exists only to try and reduce the number of methods and properties
 * in the Draw class. Basically all methods not named 'drawX' were moved in here,
 * as well as all the class fields.
 */
abstract class BaseDraw
{
    /**
     * Width of the picture
     * @var int
     */
    public $XSize;

    /**
     * Height of the picture
     * @var int
     */
    public $YSize;

    /**
     * GD picture object
     * @var resource
     */
    public $Picture;

    /**
     * Turn antialias on or off
     * @var boolean
     */
    public $Antialias = true;

    /**
     * Quality of the antialiasing implementation (0-1)
     * @var int
     */
    public $AntialiasQuality = 0;

    /**
     * Already drawn pixels mask (Filled circle implementation)
     * @var array
     */
    public $Mask = [];

    /**
     * Just to know if we need to flush the alpha channels when rendering
     * @var boolean
     */
    public $TransparentBackground = false;

    /**
     * Graph area X origin
     * @var int
     */
    public $GraphAreaX1;

    /**
     * Graph area Y origin
     * @var int
     */
    public $GraphAreaY1;

    /**
     * Graph area bottom right X position
     * @var int
     */
    public $GraphAreaX2;

    /**
     * Graph area bottom right Y position
     * @var int
     */
    public $GraphAreaY2;

    /**
     * Minimum height for scale divs
     * @var int
     */
    public $ScaleMinDivHeight = 20;

    /**
     * @var string
     */
    public $FontName = "GeosansLight.ttf";

    /**
     * @var int
     */
    public $FontSize = 12;

    /**
     * Return the bounding box of the last written string
     * @var array
     */
    public $FontBox;

    /**
     * @var int
     */
    public $FontColorR = 0;

    /**
     * @var int
     */
    public $FontColorG = 0;

    /**
     * @var int
     */
    public $FontColorB = 0;

    /**
     * @var int
     */
    public $FontColorA = 100;

    /**
     * Turn shadows on or off
     * @var boolean
     */
    public $Shadow = false;

    /**
     * X Offset of the shadow
     * @var int
     */
    public $ShadowX;

    /**
     * Y Offset of the shadow
     * @var int
     */
    public $ShadowY;

    /**
     * R component of the shadow
     * @var int
     */
    public $ShadowR;

    /**
     * G component of the shadow
     * @var int
     */
    public $ShadowG;

    /**
     * B component of the shadow
     * @var int
     */
    public $ShadowB;

    /**
     * Alpha level of the shadow
     * @var int
     */
    public $Shadowa;

    /**
     * Array containing the image map
     * @var array
     */
    public $ImageMap = [];

    /**
     * Name of the session array
     * @var int
     */
    public $ImageMapIndex = "pChart";

    /**
     * Save the current imagemap storage mode
     * @var int
     */
    public $ImageMapStorageMode;

    /**
     * Automatic deletion of the image map temp files
     * @var boolean
     */
    public $ImageMapAutoDelete = true;

    /**
     * Attached dataset
     * @var Data
     */
    public $DataSet;

    /**
     * Last generated chart info
     * Last layout : regular or stacked
     * @var int
     */
    public $LastChartLayout = CHART_LAST_LAYOUT_REGULAR;

    /**
     * @var string
     */
    private $resourcePath;

    public function __construct()
    {
        $this->resourcePath = sprintf('%s/../resources', __DIR__);
        $this->FontName = $this->loadFont($this->FontName, 'fonts');
    }

    /**
     * Set the path to the folder containing library resources (fonts, data, palettes).
     *
     * @param string $path
     * @throws Exception
     */
    public function setResourcePath($path)
    {
        $escapedPath = rtrim($path, '/');
        if (!file_exists($escapedPath)) {
            throw new Exception(sprintf(
                "The path '%s' to resources' folder does not exist!",
                $escapedPath
            ));
        }

        $this->resourcePath = $escapedPath;
    }

    /**
     * Check if requested resource exists and return the path to it if yes.
     * @param string $name
     * @param string $type
     * @return string
     * @throws Exception
     */
    protected function loadFont($name, $type)
    {
        if (file_exists($name)) {
            return $name;
        }

        $path = sprintf('%s/%s/%s', $this->resourcePath, $type, $name);
        if (file_exists($path)) {
            return $path;
        }

        throw new Exception(
            sprintf('The requested resource %s (%s) has not been found!', $name, $type)
        );
    }

    /**
     * Allocate a color with transparency
     * @param resource $Picture
     * @param int $R
     * @param int $G
     * @param int $B
     * @param int $Alpha
     * @return int
     */
    public function allocateColor($Picture, $R, $G, $B, $Alpha = 100)
    {
        if ($R < 0) {
            $R = 0;
        }
        if ($R > 255) {
            $R = 255;
        }
        if ($G < 0) {
            $G = 0;
        }
        if ($G > 255) {
            $G = 255;
        }
        if ($B < 0) {
            $B = 0;
        }
        if ($B > 255) {
            $B = 255;
        }
        if ($Alpha < 0) {
            $Alpha = 0;
        }
        if ($Alpha > 100) {
            $Alpha = 100;
        }

        $Alpha = $this->convertAlpha($Alpha);
        return imagecolorallocatealpha($Picture, (int) $R, (int) $G, (int) $B, (int) $Alpha);
    }

    /**
     * Convert apha to base 10
     * @param int|float $AlphaValue
     * @return integer
     */
    public function convertAlpha($AlphaValue)
    {
        return floor((127 / 100) * (100 - $AlphaValue));
    }

    /**
     * @param string $FileName
     * @return array
     */
    public function getPicInfo($FileName)
    {
        $Infos = getimagesize($FileName);
        $Width = $Infos[0];
        $Height = $Infos[1];
        $Type = $Infos["mime"];

        if ($Type == "image/png") {
            $Type = 1;
        }
        if ($Type == "image/gif") {
            $Type = 2;
        }
        if ($Type == "image/jpeg ") {
            $Type = 3;
        }

        return [$Width, $Height, $Type];
    }

    /**
     * Compute the scale, check for the best visual factors
     * @param int $XMin
     * @param int $XMax
     * @param int $MaxDivs
     * @param array $Factors
     * @param int $AxisID
     * @return mixed
     */
    public function computeScale($XMin, $XMax, $MaxDivs, array $Factors, $AxisID = 0)
    {
        /* Compute each factors */
        $Results = [];
        foreach ($Factors as $Key => $Factor) {
            $Results[$Factor] = $this->processScale($XMin, $XMax, $MaxDivs, [$Factor], $AxisID);
        }
        /* Remove scales that are creating to much decimals */
        $GoodScaleFactors = [];
        foreach ($Results as $Key => $Result) {
            $Decimals = preg_split("/\./", $Result["RowHeight"]);
            if ((!isset($Decimals[1])) || (strlen($Decimals[1]) < 6)) {
                $GoodScaleFactors[] = $Key;
            }
        }

        /* Found no correct scale, shame,... returns the 1st one as default */
        if (!count($GoodScaleFactors)) {
            return $Results[$Factors[0]];
        }

        /* Find the factor that cause the maximum number of Rows */
        $MaxRows = 0;
        $BestFactor = 0;
        foreach ($GoodScaleFactors as $Key => $Factor) {
            if ($Results[$Factor]["Rows"] > $MaxRows) {
                $MaxRows = $Results[$Factor]["Rows"];
                $BestFactor = $Factor;
            }
        }

        /* Return the best visual scale */
        return $Results[$BestFactor];
    }

    /**
     * Compute the best matching scale based on size & factors
     * @param int $XMin
     * @param int $XMax
     * @param int $MaxDivs
     * @param array $Factors
     * @param int $AxisID
     * @return array
     */
    public function processScale($XMin, $XMax, $MaxDivs, array $Factors, $AxisID)
    {
        $ScaleHeight = abs(ceil($XMax) - floor($XMin));

        $Format = null;
        if (isset($this->DataSet->Data["Axis"][$AxisID]["Format"])) {
            $Format = $this->DataSet->Data["Axis"][$AxisID]["Format"];
        }

        $Mode = AXIS_FORMAT_DEFAULT;
        if (isset($this->DataSet->Data["Axis"][$AxisID]["Display"])) {
            $Mode = $this->DataSet->Data["Axis"][$AxisID]["Display"];
        }

        $Scale = [];
        if ($XMin != $XMax) {
            $Found = false;
            $Rescaled = false;
            $Scaled10Factor = .0001;
            $Result = 0;
            while (!$Found) {
                foreach ($Factors as $Key => $Factor) {
                    if (!$Found) {
                        $XMinRescaled = $XMin;
                        if (!($this->modulo($XMin, $Factor * $Scaled10Factor) == 0)
                            || ($XMin != floor($XMin))
                        ) {
                            $XMinRescaled = floor($XMin / ($Factor * $Scaled10Factor))
                                * $Factor
                                * $Scaled10Factor
                            ;
                        }

                        $XMaxRescaled = $XMax;
                        if (!($this->modulo($XMax, $Factor * $Scaled10Factor) == 0)
                            || ($XMax != floor($XMax))
                        ) {
                            $XMaxRescaled = floor($XMax / ($Factor * $Scaled10Factor))
                                * $Factor
                                * $Scaled10Factor
                                + ($Factor * $Scaled10Factor)
                            ;
                        }

                        $ScaleHeightRescaled = abs($XMaxRescaled - $XMinRescaled);

                        if (!$Found
                            && floor($ScaleHeightRescaled / ($Factor * $Scaled10Factor)) <= $MaxDivs
                        ) {
                            $Found = true;
                            $Rescaled = true;
                            $Result = $Factor * $Scaled10Factor;
                        }
                    }
                }
                $Scaled10Factor = $Scaled10Factor * 10;
            }

            /* ReCall Min / Max / Height */
            if ($Rescaled) {
                $XMin = $XMinRescaled;
                $XMax = $XMaxRescaled;
                $ScaleHeight = $ScaleHeightRescaled;
            }

            /* Compute rows size */
            $Rows = floor($ScaleHeight / $Result);
            if ($Rows == 0) {
                $Rows = 1;
            }
            $RowHeight = $ScaleHeight / $Rows;

            /* Return the results */
            $Scale["Rows"] = $Rows;
            $Scale["RowHeight"] = $RowHeight;
            $Scale["XMin"] = $XMin;
            $Scale["XMax"] = $XMax;

            /* Compute the needed decimals for the metric view to avoid repetition of the same X Axis labels */
            if ($Mode == AXIS_FORMAT_METRIC && $Format == null) {
                $Done = false;
                $GoodDecimals = 0;
                for ($Decimals = 0; $Decimals <= 10; $Decimals++) {
                    if (!$Done) {
                        $LastLabel = "zob";
                        $ScaleOK = true;
                        for ($i = 0; $i <= $Rows; $i++) {
                            $Value = $XMin + $i * $RowHeight;
                            $Label = $this->scaleFormat($Value, AXIS_FORMAT_METRIC, $Decimals);

                            if ($LastLabel == $Label) {
                                $ScaleOK = false;
                            }
                            $LastLabel = $Label;
                        }
                        if ($ScaleOK) {
                            $Done = true;
                            $GoodDecimals = $Decimals;
                        }
                    }
                }
                $Scale["Format"] = $GoodDecimals;
            }
        } else {
            /* If all values are the same we keep a +1/-1 scale */
            $Rows = 2;
            $XMin = $XMax - 1;
            $XMax = $XMax + 1;
            $RowHeight = 1;

            /* Return the results */
            $Scale["Rows"] = $Rows;
            $Scale["RowHeight"] = $RowHeight;
            $Scale["XMin"] = $XMin;
            $Scale["XMax"] = $XMax;
        }

        return $Scale;
    }

    /**
     *
     * @param int|float $Value1
     * @param int|float $Value2
     * @return double
     */
    public function modulo($Value1, $Value2)
    {
        if (floor($Value2) == 0) {
            return 0;
        }
        if (floor($Value2) != 0) {
            return (int) $Value1 % (int) $Value2;
        }

        $MinValue = min($Value1, $Value2);
        $Factor = 10;
        while (floor($MinValue * $Factor) == 0) {
            $Factor = $Factor * 10;
        }

        return floor($Value1 * $Factor) % floor($Value2 * $Factor);
    }

    /**
     * @param mixed $Value
     * @param mixed $LastValue
     * @param integer $LabelingMethod
     * @param integer $ID
     * @param boolean $LabelSkip
     * @return boolean
     */
    public function isValidLabel($Value, $LastValue, $LabelingMethod, $ID, $LabelSkip)
    {
        if ($LabelingMethod == LABELING_DIFFERENT && $Value != $LastValue) {
            return true;
        }
        if ($LabelingMethod == LABELING_DIFFERENT && $Value == $LastValue) {
            return false;
        }
        if ($LabelingMethod == LABELING_ALL && $LabelSkip == 0) {
            return true;
        }
        if ($LabelingMethod == LABELING_ALL && ($ID + $LabelSkip) % ($LabelSkip + 1) != 1) {
            return false;
        }

        return true;
    }

    /**
     * Returns the number of drawable series
     * @return int
     */
    public function countDrawableSeries()
    {
        $count = 0;
        $Data = $this->DataSet->getData();

        foreach ($Data["Series"] as $SerieName => $Serie) {
            if ($Serie["isDrawable"] == true && $SerieName != $Data["Abscissa"]) {
                $count++;
            }
        }

        return $count;
    }

    /**
     * Fix box coordinates
     * @param int $Xa
     * @param int $Ya
     * @param int $Xb
     * @param int $Yb
     * @return integer[]
     */
    public function fixBoxCoordinates($Xa, $Ya, $Xb, $Yb)
    {
        return [
            (int) min($Xa, $Xb),
            (int) min($Ya, $Yb),
            (int) max($Xa, $Xb),
            (int) max($Ya, $Yb)
        ];
    }

    /**
     * Apply AALias correction to the rounded box boundaries
     * @param int|float $Value
     * @param int $Mode
     * @return int|float
     */
    public function offsetCorrection($Value, $Mode)
    {
        $Value = round($Value, 1);

        if ($Value == 0 && $Mode != 1) {
            return 0;
        }

        if ($Mode == 1) {
            if ($Value == .5) {
                return .5;
            }
            if ($Value == .8) {
                return .6;
            }
            if (in_array($Value, [.4, .7])) {
                return .7;
            }
            if (in_array($Value, [.2, .3, .6])) {
                return .8;
            }
            if (in_array($Value, [0, 1, .1, .9])) {
                return .9;
            }
        }

        if ($Mode == 2) {
            if ($Value == .1) {
                return .1;
            }
            if ($Value == .2) {
                return .2;
            }
            if ($Value == .3) {
                return .3;
            }
            if ($Value == .4) {
                return .4;
            }
            if ($Value == .5) {
                return .5;
            }
            if ($Value == .7) {
                return .7;
            }
            if (in_array($Value, [.6, .8])) {
                return .8;
            }
            if (in_array($Value, [1, .9])) {
                return .9;
            }
        }

        if ($Mode == 3) {
            if (in_array($Value, [1, .1])) {
                return .1;
            }
            if ($Value == .2) {
                return .2;
            }
            if ($Value == .3) {
                return .3;
            }
            if (in_array($Value, [.4, .8])) {
                return .4;
            }
            if ($Value == .5) {
                return .9;
            }
            if ($Value == .6) {
                return .6;
            }
            if ($Value == .7) {
                return .7;
            }
            if ($Value == .9) {
                return .5;
            }
        }

        if ($Mode == 4) {
            if ($Value == 1) {
                return -1;
            }
            if (in_array($Value, [.1, .4, .7, .8, .9])) {
                return .1;
            }
            if ($Value == .2) {
                return .2;
            }
            if ($Value == .3) {
                return .3;
            }
            if ($Value == .5) {
                return -.1;
            }
            if ($Value == .6) {
                return .8;
            }
        }
    }

    /**
     * Get the legend box size
     * @param array $Format
     * @return array
     */
    public function getLegendSize(array $Format = [])
    {
        $FontName = isset($Format["FontName"]) ? $this->loadFont($Format["FontName"], 'fonts') : $this->FontName;
        $FontSize = isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
        $Margin = isset($Format["Margin"]) ? $Format["Margin"] : 5;
        $Mode = isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;
        $BoxWidth = isset($Format["BoxWidth"]) ? $Format["BoxWidth"] : 5;
        $BoxHeight = isset($Format["BoxHeight"]) ? $Format["BoxHeight"] : 5;
        $IconAreaWidth = isset($Format["IconAreaWidth"]) ? $Format["IconAreaWidth"] : $BoxWidth;
        $IconAreaHeight = isset($Format["IconAreaHeight"]) ? $Format["IconAreaHeight"] : $BoxHeight;
        $XSpacing = isset($Format["XSpacing"]) ? $Format["XSpacing"] : 5;

        $Data = $this->DataSet->getData();

        foreach ($Data["Series"] as $SerieName => $Serie) {
            if ($Serie["isDrawable"] == true
                && $SerieName != $Data["Abscissa"]
                && isset($Serie["Picture"])
            ) {
                list($PicWidth, $PicHeight) = $this->getPicInfo($Serie["Picture"]);
                if ($IconAreaWidth < $PicWidth) {
                    $IconAreaWidth = $PicWidth;
                }
                if ($IconAreaHeight < $PicHeight) {
                    $IconAreaHeight = $PicHeight;
                }
            }
        }

        $YStep = max($this->FontSize, $IconAreaHeight) + 5;
        $XStep = $IconAreaWidth + 5;
        $XStep = $XSpacing;

        $X = 100;
        $Y = 100;

        $Boundaries = [];
        $Boundaries["L"] = $X;
        $Boundaries["T"] = $Y;
        $Boundaries["R"] = 0;
        $Boundaries["B"] = 0;
        $vY = $Y;
        $vX = $X;
        foreach ($Data["Series"] as $SerieName => $Serie) {
            if ($Serie["isDrawable"] == true && $SerieName != $Data["Abscissa"]) {
                if ($Mode == LEGEND_VERTICAL) {
                    $BoxArray = $this->getTextBox(
                        $vX + $IconAreaWidth + 4,
                        $vY + $IconAreaHeight / 2,
                        $FontName,
                        $FontSize,
                        0,
                        $Serie["Description"]
                    );

                    if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
                        $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
                    }
                    if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
                        $Boundaries["R"] = $BoxArray[1]["X"] + 2;
                    }
                    if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
                        $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
                    }

                    $Lines = preg_split("/\n/", $Serie["Description"]);
                    $vY = $vY + max($this->FontSize * count($Lines), $IconAreaHeight) + 5;
                } elseif ($Mode == LEGEND_HORIZONTAL) {
                    $Lines = preg_split("/\n/", $Serie["Description"]);
                    $Width = [];
                    foreach ($Lines as $Key => $Value) {
                        $BoxArray = $this->getTextBox(
                            $vX + $IconAreaWidth + 6,
                            $Y + $IconAreaHeight / 2 + (($this->FontSize + 3) * $Key),
                            $FontName,
                            $FontSize,
                            0,
                            $Value
                        );

                        if ($Boundaries["T"] > $BoxArray[2]["Y"] + $IconAreaHeight / 2) {
                            $Boundaries["T"] = $BoxArray[2]["Y"] + $IconAreaHeight / 2;
                        }
                        if ($Boundaries["R"] < $BoxArray[1]["X"] + 2) {
                            $Boundaries["R"] = $BoxArray[1]["X"] + 2;
                        }
                        if ($Boundaries["B"] < $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2) {
                            $Boundaries["B"] = $BoxArray[1]["Y"] + 2 + $IconAreaHeight / 2;
                        }

                        $Width[] = $BoxArray[1]["X"];
                    }

                    $vX = max($Width) + $XStep;
                }
            }
        }
        $vY = $vY - $YStep;
        $vX = $vX - $XStep;

        $TopOffset = $Y - $Boundaries["T"];
        if ($Boundaries["B"] - ($vY + $IconAreaHeight) < $TopOffset) {
            $Boundaries["B"] = $vY + $IconAreaHeight + $TopOffset;
        }

        $Width = ($Boundaries["R"] + $Margin) - ($Boundaries["L"] - $Margin);
        $Height = ($Boundaries["B"] + $Margin) - ($Boundaries["T"] - $Margin);

        return ["Width" => $Width, "Height" => $Height];
    }

    /**
     * Return the abscissa margin
     * @param array $Data
     * @return int
     */
    public function getAbscissaMargin(array $Data)
    {
        foreach ($Data["Axis"] as $Values) {
            if ($Values["Identity"] == AXIS_X) {
                return $Values["Margin"];
            }
        }
        return 0;
    }

    /**
     * Returns a random color
     * @param int $Alpha
     * @return array
     */
    public function getRandomColor($Alpha = 100)
    {
        return [
            "R" => rand(0, 255),
            "G" => rand(0, 255),
            "B" => rand(0, 255),
            "Alpha" => $Alpha
        ];
    }

    /**
     * Validate a palette
     * @param mixed $Colors
     * @param int|float $Surrounding
     * @return array
     */
    public function validatePalette($Colors, $Surrounding = null)
    {
        $Result = [];

        if (!is_array($Colors)) {
            return $this->getRandomColor();
        }

        foreach ($Colors as $Key => $Values) {
            if (isset($Values["R"])) {
                $Result[$Key]["R"] = $Values["R"];
            } else {
                $Result[$Key]["R"] = rand(0, 255);
            }

            if (isset($Values["G"])) {
                $Result[$Key]["G"] = $Values["G"];
            } else {
                $Result[$Key]["G"] = rand(0, 255);
            }

            if (isset($Values["B"])) {
                $Result[$Key]["B"] = $Values["B"];
            } else {
                $Result[$Key]["B"] = rand(0, 255);
            }
            if (isset($Values["Alpha"])) {
                $Result[$Key]["Alpha"] = $Values["Alpha"];
            } else {
                $Result[$Key]["Alpha"] = 100;
            }

            if (null !== $Surrounding) {
                $Result[$Key]["BorderR"] = $Result[$Key]["R"] + $Surrounding;
                $Result[$Key]["BorderG"] = $Result[$Key]["G"] + $Surrounding;
                $Result[$Key]["BorderB"] = $Result[$Key]["B"] + $Surrounding;
            } else {
                if (isset($Values["BorderR"])) {
                    $Result[$Key]["BorderR"] = $Values["BorderR"];
                } else {
                    $Result[$Key]["BorderR"] = $Result[$Key]["R"];
                }
                if (isset($Values["BorderG"])) {
                    $Result[$Key]["BorderG"] = $Values["BorderG"];
                } else {
                    $Result[$Key]["BorderG"] = $Result[$Key]["G"];
                }
                if (isset($Values["BorderB"])) {
                    $Result[$Key]["BorderB"] = $Values["BorderB"];
                } else {
                    $Result[$Key]["BorderB"] = $Result[$Key]["B"];
                }
                if (isset($Values["BorderAlpha"])) {
                    $Result[$Key]["BorderAlpha"] = $Values["BorderAlpha"];
                } else {
                    $Result[$Key]["BorderAlpha"] = $Result[$Key]["Alpha"];
                }
            }
        }

        return $Result;
    }

    /**
     * @param mixed $Values
     * @param array $Option
     * @param boolean $ReturnOnly0Height
     * @return int|float|array
     */
    public function scaleComputeY($Values, array $Option = [], $ReturnOnly0Height = false)
    {
        $AxisID = isset($Option["AxisID"]) ? $Option["AxisID"] : 0;
        $SerieName = isset($Option["SerieName"]) ? $Option["SerieName"] : null;

        $Data = $this->DataSet->getData();
        if (!isset($Data["Axis"][$AxisID])) {
            return -1;
        }

        if ($SerieName != null) {
            $AxisID = $Data["Series"][$SerieName]["Axis"];
        }
        if (!is_array($Values)) {
            $tmp = $Values;
            $Values = [];
            $Values[0] = $tmp;
        }

        $Result = [];
        if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
            $Height = ($this->GraphAreaY2 - $this->GraphAreaY1) - $Data["Axis"][$AxisID]["Margin"] * 2;
            $ScaleHeight = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
            $Step = $Height / $ScaleHeight;

            if ($ReturnOnly0Height) {
                foreach ($Values as $Key => $Value) {
                    if ($Value == VOID) {
                        $Result[] = VOID;
                    } else {
                        $Result[] = $Step * $Value;
                    }
                }
            } else {
                foreach ($Values as $Key => $Value) {
                    if ($Value == VOID) {
                        $Result[] = VOID;
                    } else {
                        $Result[] = $this->GraphAreaY2
                            - $Data["Axis"][$AxisID]["Margin"]
                            - ($Step * ($Value - $Data["Axis"][$AxisID]["ScaleMin"]))
                        ;
                    }
                }
            }
        } else {
            $Width = ($this->GraphAreaX2 - $this->GraphAreaX1) - $Data["Axis"][$AxisID]["Margin"] * 2;
            $ScaleWidth = $Data["Axis"][$AxisID]["ScaleMax"] - $Data["Axis"][$AxisID]["ScaleMin"];
            $Step = $Width / $ScaleWidth;

            if ($ReturnOnly0Height) {
                foreach ($Values as $Key => $Value) {
                    if ($Value == VOID) {
                        $Result[] = VOID;
                    } else {
                        $Result[] = $Step * $Value;
                    }
                }
            } else {
                foreach ($Values as $Key => $Value) {
                    if ($Value == VOID) {
                        $Result[] = VOID;
                    } else {
                        $Result[] = $this->GraphAreaX1
                            + $Data["Axis"][$AxisID]["Margin"]
                            + ($Step * ($Value - $Data["Axis"][$AxisID]["ScaleMin"]))
                        ;
                    }
                }
            }
        }
        return count($Result) == 1 ? reset($Result) : $Result;
    }

    /**
     * Format the axis values
     * @param mixed $Value
     * @param int $Mode
     * @param array $Format
     * @param string $Unit
     * @return string
     */
    public function scaleFormat($Value, $Mode = null, $Format = null, $Unit = null)
    {
        if ($Value == VOID) {
            return "";
        }

        if ($Mode == AXIS_FORMAT_TRAFFIC) {
            if ($Value == 0) {
                return "0B";
            }
            $Units = ["B", "KB", "MB", "GB", "TB", "PB"];
            $Sign = "";
            if ($Value < 0) {
                $Value = abs($Value);
                $Sign = "-";
            }

            $Value = number_format($Value / pow(1024, ($Scale = floor(log($Value, 1024)))), 2, ",", ".");
            return $Sign . $Value . " " . $Units[$Scale];
        }

        if ($Mode == AXIS_FORMAT_CUSTOM) {
            if (is_callable($Format)) {
                return call_user_func($Format, $Value);
            }
        }

        if ($Mode == AXIS_FORMAT_DATE) {
            $Pattern = "d/m/Y";
            if ($Format !== null) {
                $Pattern = $Format;
            }

            return gmdate($Pattern, $Value);
        }

        if ($Mode == AXIS_FORMAT_TIME) {
            $Pattern = "H:i:s";
            if ($Format !== null) {
                $Pattern = $Format;
            }

            return gmdate($Pattern, $Value);
        }

        if ($Mode == AXIS_FORMAT_CURRENCY) {
            return $Format . number_format($Value, 2);
        }

        if ($Mode == AXIS_FORMAT_METRIC) {
            if (abs($Value) > 1000000000) {
                return round($Value / 1000000000, $Format) . "g" . $Unit;
            }
            if (abs($Value) > 1000000) {
                return round($Value / 1000000, $Format) . "m" . $Unit;
            } elseif (abs($Value) >= 1000) {
                return round($Value / 1000, $Format) . "k" . $Unit;
            }
        }
        return $Value . $Unit;
    }

    /**
     * @return array|null
     */
    public function scaleGetXSettings()
    {
        $Data = $this->DataSet->getData();
        foreach ($Data["Axis"] as $Settings) {
            if ($Settings["Identity"] == AXIS_X) {
                return [$Settings["Margin"], $Settings["Rows"]];
            }
        }
    }

    /**
     * Write Max value on a chart
     * @param int $Type
     * @param array $Format
     */
    public function writeBounds($Type = BOUND_BOTH, $Format = null)
    {
        $MaxLabelTxt = isset($Format["MaxLabelTxt"]) ? $Format["MaxLabelTxt"] : "max=";
        $MinLabelTxt = isset($Format["MinLabelTxt"]) ? $Format["MinLabelTxt"] : "min=";
        $Decimals = isset($Format["Decimals"]) ? $Format["Decimals"] : 1;
        $ExcludedSeries = isset($Format["ExcludedSeries"]) ? $Format["ExcludedSeries"] : "";
        $DisplayOffset = isset($Format["DisplayOffset"]) ? $Format["DisplayOffset"] : 4;
        $DisplayColor = isset($Format["DisplayColor"]) ? $Format["DisplayColor"] : DISPLAY_MANUAL;
        $MaxDisplayR = isset($Format["MaxDisplayR"]) ? $Format["MaxDisplayR"] : 0;
        $MaxDisplayG = isset($Format["MaxDisplayG"]) ? $Format["MaxDisplayG"] : 0;
        $MaxDisplayB = isset($Format["MaxDisplayB"]) ? $Format["MaxDisplayB"] : 0;
        $MinDisplayR = isset($Format["MinDisplayR"]) ? $Format["MinDisplayR"] : 255;
        $MinDisplayG = isset($Format["MinDisplayG"]) ? $Format["MinDisplayG"] : 255;
        $MinDisplayB = isset($Format["MinDisplayB"]) ? $Format["MinDisplayB"] : 255;
        $MinLabelPos = isset($Format["MinLabelPos"]) ? $Format["MinLabelPos"] : BOUND_LABEL_POS_AUTO;
        $MaxLabelPos = isset($Format["MaxLabelPos"]) ? $Format["MaxLabelPos"] : BOUND_LABEL_POS_AUTO;
        $DrawBox = isset($Format["DrawBox"]) ? $Format["DrawBox"] : true;
        $DrawBoxBorder = isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : false;
        $BorderOffset = isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 5;
        $BoxRounded = isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : true;
        $RoundedRadius = isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 3;
        $BoxR = isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
        $BoxG = isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
        $BoxB = isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
        $BoxAlpha = isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 20;
        $BoxSurrounding = isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
        $BoxBorderR = isset($Format["BoxBorderR"]) ? $Format["BoxBorderR"] : 255;
        $BoxBorderG = isset($Format["BoxBorderG"]) ? $Format["BoxBorderG"] : 255;
        $BoxBorderB = isset($Format["BoxBorderB"]) ? $Format["BoxBorderB"] : 255;
        $BoxBorderAlpha = isset($Format["BoxBorderAlpha"]) ? $Format["BoxBorderAlpha"] : 100;

        $CaptionSettings = [
            "DrawBox" => $DrawBox,
            "DrawBoxBorder" => $DrawBoxBorder,
            "BorderOffset" => $BorderOffset,
            "BoxRounded" => $BoxRounded,
            "RoundedRadius" => $RoundedRadius,
            "BoxR" => $BoxR,
            "BoxG" => $BoxG,
            "BoxB" => $BoxB,
            "BoxAlpha" => $BoxAlpha,
            "BoxSurrounding" => $BoxSurrounding,
            "BoxBorderR" => $BoxBorderR,
            "BoxBorderG" => $BoxBorderG,
            "BoxBorderB" => $BoxBorderB,
            "BoxBorderAlpha" => $BoxBorderAlpha
        ];

        list($XMargin, $XDivs) = $this->scaleGetXSettings();

        $Data = $this->DataSet->getData();
        foreach ($Data["Series"] as $SerieName => $Serie) {
            if ($Serie["isDrawable"] == true
                && $SerieName != $Data["Abscissa"]
                && !isset($ExcludedSeries[$SerieName])
            ) {
                $R = $Serie["Color"]["R"];
                $G = $Serie["Color"]["G"];
                $B = $Serie["Color"]["B"];

                $MinValue = $this->DataSet->getMin($SerieName);
                $MaxValue = $this->DataSet->getMax($SerieName);

                $MinPos = VOID;
                $MaxPos = VOID;
                foreach ($Serie["Data"] as $Key => $Value) {
                    if ($Value == $MinValue && $MinPos == VOID) {
                        $MinPos = $Key;
                    }
                    if ($Value == $MaxValue) {
                        $MaxPos = $Key;
                    }
                }

                $AxisID = $Serie["Axis"];
                $Mode = $Data["Axis"][$AxisID]["Display"];
                $Format = $Data["Axis"][$AxisID]["Format"];
                $Unit = $Data["Axis"][$AxisID]["Unit"];

                $PosArray = $this->scaleComputeY(
                    $Serie["Data"],
                    ["AxisID" => $Serie["Axis"]]
                );

                if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
                    $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
                    $X = $this->GraphAreaX1 + $XMargin;
                    $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;

                    if ($Type == BOUND_MAX || $Type == BOUND_BOTH) {
                        if ($MaxLabelPos == BOUND_LABEL_POS_TOP
                            || ($MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue >= 0)
                        ) {
                            $YPos = $PosArray[$MaxPos] - $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                        }
                        if ($MaxLabelPos == BOUND_LABEL_POS_BOTTOM
                            || ($MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue < 0)
                        ) {
                            $YPos = $PosArray[$MaxPos] + $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_TOPMIDDLE;
                        }

                        $XPos = $X + $MaxPos * $XStep + $SerieOffset;
                        $Label = sprintf(
                            '%s%s',
                            $MaxLabelTxt,
                            $this->scaleFormat(round($MaxValue, $Decimals), $Mode, $Format, $Unit)
                        );

                        $TxtPos = $this->getTextBox($XPos, $YPos, $this->FontName, $this->FontSize, 0, $Label);
                        $XOffset = 0;
                        $YOffset = 0;
                        if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
                            $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"]) / 2);
                        }
                        if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
                            $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2) / 2);
                        }
                        if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
                            $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"];
                        }
                        if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
                            $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2);
                        }

                        $CaptionSettings["R"] = $MaxDisplayR;
                        $CaptionSettings["G"] = $MaxDisplayG;
                        $CaptionSettings["B"] = $MaxDisplayB;
                        $CaptionSettings["Align"] = $Align;

                        $this->drawText($XPos + $XOffset, $YPos + $YOffset, $Label, $CaptionSettings);
                    }

                    if ($Type == BOUND_MIN || $Type == BOUND_BOTH) {
                        if ($MinLabelPos == BOUND_LABEL_POS_TOP
                            || ($MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue >= 0)
                        ) {
                            $YPos = $PosArray[$MinPos] - $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_BOTTOMMIDDLE;
                        }
                        if ($MinLabelPos == BOUND_LABEL_POS_BOTTOM
                            || ($MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue < 0)
                        ) {
                            $YPos = $PosArray[$MinPos] + $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_TOPMIDDLE;
                        }

                        $XPos = $X + $MinPos * $XStep + $SerieOffset;
                        $Label = sprintf(
                            '%s%s',
                            $MinLabelTxt,
                            $this->scaleFormat(round($MinValue, $Decimals), $Mode, $Format, $Unit)
                        );

                        $TxtPos = $this->getTextBox($XPos, $YPos, $this->FontName, $this->FontSize, 0, $Label);
                        $XOffset = 0;
                        $YOffset = 0;
                        if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
                            $XOffset = (($this->GraphAreaX1 - $TxtPos[0]["X"]) / 2);
                        }
                        if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
                            $XOffset = -(($TxtPos[1]["X"] - $this->GraphAreaX2) / 2);
                        }
                        if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
                            $YOffset = $this->GraphAreaY1 - $TxtPos[2]["Y"];
                        }
                        if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
                            $YOffset = -($TxtPos[0]["Y"] - $this->GraphAreaY2);
                        }

                        $CaptionSettings["R"] = $MinDisplayR;
                        $CaptionSettings["G"] = $MinDisplayG;
                        $CaptionSettings["B"] = $MinDisplayB;
                        $CaptionSettings["Align"] = $Align;

                        $this->drawText(
                            $XPos + $XOffset,
                            $YPos - $DisplayOffset + $YOffset,
                            $Label,
                            $CaptionSettings
                        );
                    }
                } else {
                    $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
                    $X = $this->GraphAreaY1 + $XMargin;
                    $SerieOffset = isset($Serie["XOffset"]) ? $Serie["XOffset"] : 0;

                    if ($Type == BOUND_MAX || $Type == BOUND_BOTH) {
                        if ($MaxLabelPos == BOUND_LABEL_POS_TOP
                            || ($MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue >= 0)
                        ) {
                            $YPos = $PosArray[$MaxPos] + $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_MIDDLELEFT;
                        }
                        if ($MaxLabelPos == BOUND_LABEL_POS_BOTTOM
                            || ($MaxLabelPos == BOUND_LABEL_POS_AUTO && $MaxValue < 0)
                        ) {
                            $YPos = $PosArray[$MaxPos] - $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_MIDDLERIGHT;
                        }

                        $XPos = $X + $MaxPos * $XStep + $SerieOffset;
                        $Label = $MaxLabelTxt . $this->scaleFormat($MaxValue, $Mode, $Format, $Unit);

                        $TxtPos = $this->getTextBox($YPos, $XPos, $this->FontName, $this->FontSize, 0, $Label);
                        $XOffset = 0;
                        $YOffset = 0;
                        if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
                            $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"];
                        }
                        if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
                            $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2);
                        }
                        if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
                            $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"]) / 2;
                        }
                        if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
                            $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2) / 2);
                        }

                        $CaptionSettings["R"] = $MaxDisplayR;
                        $CaptionSettings["G"] = $MaxDisplayG;
                        $CaptionSettings["B"] = $MaxDisplayB;
                        $CaptionSettings["Align"] = $Align;

                        $this->drawText($YPos + $XOffset, $XPos + $YOffset, $Label, $CaptionSettings);
                    }

                    if ($Type == BOUND_MIN || $Type == BOUND_BOTH) {
                        if ($MinLabelPos == BOUND_LABEL_POS_TOP
                            || ($MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue >= 0)
                        ) {
                            $YPos = $PosArray[$MinPos] + $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_MIDDLELEFT;
                        }
                        if ($MinLabelPos == BOUND_LABEL_POS_BOTTOM
                            || ($MinLabelPos == BOUND_LABEL_POS_AUTO && $MinValue < 0)
                        ) {
                            $YPos = $PosArray[$MinPos] - $DisplayOffset + 2;
                            $Align = TEXT_ALIGN_MIDDLERIGHT;
                        }

                        $XPos = $X + $MinPos * $XStep + $SerieOffset;
                        $Label = $MinLabelTxt . $this->scaleFormat($MinValue, $Mode, $Format, $Unit);

                        $TxtPos = $this->getTextBox($YPos, $XPos, $this->FontName, $this->FontSize, 0, $Label);
                        $XOffset = 0;
                        $YOffset = 0;
                        if ($TxtPos[0]["X"] < $this->GraphAreaX1) {
                            $XOffset = $this->GraphAreaX1 - $TxtPos[0]["X"];
                        }
                        if ($TxtPos[1]["X"] > $this->GraphAreaX2) {
                            $XOffset = -($TxtPos[1]["X"] - $this->GraphAreaX2);
                        }
                        if ($TxtPos[2]["Y"] < $this->GraphAreaY1) {
                            $YOffset = ($this->GraphAreaY1 - $TxtPos[2]["Y"]) / 2;
                        }
                        if ($TxtPos[0]["Y"] > $this->GraphAreaY2) {
                            $YOffset = -(($TxtPos[0]["Y"] - $this->GraphAreaY2) / 2);
                        }

                        $CaptionSettings["R"] = $MinDisplayR;
                        $CaptionSettings["G"] = $MinDisplayG;
                        $CaptionSettings["B"] = $MinDisplayB;
                        $CaptionSettings["Align"] = $Align;

                        $this->drawText($YPos + $XOffset, $XPos + $YOffset, $Label, $CaptionSettings);
                    }
                }
            }
        }
    }

    /**
     * Write labels
     * @param string $SeriesName
     * @param array $Indexes
     * @param array $Format
     */
    public function writeLabel($SeriesName, $Indexes, array $Format = [])
    {
        $OverrideTitle = isset($Format["OverrideTitle"]) ? $Format["OverrideTitle"] : null;
        $ForceLabels = isset($Format["ForceLabels"]) ? $Format["ForceLabels"] : null;
        $DrawPoint = isset($Format["DrawPoint"]) ? $Format["DrawPoint"] : LABEL_POINT_BOX;
        $DrawVerticalLine = isset($Format["DrawVerticalLine"]) ? $Format["DrawVerticalLine"] : false;
        $VerticalLineR = isset($Format["VerticalLineR"]) ? $Format["VerticalLineR"] : 0;
        $VerticalLineG = isset($Format["VerticalLineG"]) ? $Format["VerticalLineG"] : 0;
        $VerticalLineB = isset($Format["VerticalLineB"]) ? $Format["VerticalLineB"] : 0;
        $VerticalLineAlpha = isset($Format["VerticalLineAlpha"]) ? $Format["VerticalLineAlpha"] : 40;
        $VerticalLineTicks = isset($Format["VerticalLineTicks"]) ? $Format["VerticalLineTicks"] : 2;

        $Data = $this->DataSet->getData();
        list($XMargin, $XDivs) = $this->scaleGetXSettings();

        if (!is_array($Indexes)) {
            $Index = $Indexes;
            $Indexes = [];
            $Indexes[] = $Index;
        }
        if (!is_array($SeriesName)) {
            $SerieName = $SeriesName;
            $SeriesName = [];
            $SeriesName[] = $SerieName;
        }
        if ($ForceLabels != null && !is_array($ForceLabels)) {
            $ForceLabel = $ForceLabels;
            $ForceLabels = [];
            $ForceLabels[] = $ForceLabel;
        }

        foreach ($Indexes as $Key => $Index) {
            $Series = [];

            if ($Data["Orientation"] == SCALE_POS_LEFTRIGHT) {
                if ($XDivs == 0) {
                    $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1) / 4;
                } else {
                    $XStep = ($this->GraphAreaX2 - $this->GraphAreaX1 - $XMargin * 2) / $XDivs;
                }
                $X = $this->GraphAreaX1 + $XMargin + $Index * $XStep;

                if ($DrawVerticalLine) {
                    $this->drawLine(
                        $X,
                        $this->GraphAreaY1 + $Data["YMargin"],
                        $X,
                        $this->GraphAreaY2 - $Data["YMargin"],
                        [
                            "R" => $VerticalLineR,
                            "G" => $VerticalLineG,
                            "B" => $VerticalLineB,
                            "Alpha" => $VerticalLineAlpha,
                            "Ticks" => $VerticalLineTicks
                        ]
                    );
                }

                $MinY = $this->GraphAreaY2;
                foreach ($SeriesName as $SerieName) {
                    if (isset($Data["Series"][$SerieName]["Data"][$Index])) {
                        $AxisID = $Data["Series"][$SerieName]["Axis"];
                        $XAxisMode = $Data["XAxisDisplay"];
                        $XAxisFormat = $Data["XAxisFormat"];
                        $XAxisUnit = $Data["XAxisUnit"];
                        $AxisMode = $Data["Axis"][$AxisID]["Display"];
                        $AxisFormat = $Data["Axis"][$AxisID]["Format"];
                        $AxisUnit = $Data["Axis"][$AxisID]["Unit"];
                        $XLabel = "";

                        if (isset($Data["Abscissa"])
                            && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])
                        ) {
                            $XLabel = $this->scaleFormat(
                                $Data["Series"][$Data["Abscissa"]]["Data"][$Index],
                                $XAxisMode,
                                $XAxisFormat,
                                $XAxisUnit
                            );
                        }

                        if ($OverrideTitle != null) {
                            $Description = $OverrideTitle;
                        } elseif (count($SeriesName) == 1) {
                            $Description = $Data["Series"][$SerieName]["Description"] . " - " . $XLabel;
                        } elseif (isset($Data["Abscissa"])
                            && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])
                        ) {
                            $Description = $XLabel;
                        }

                        $Serie = [
                            "R" => $Data["Series"][$SerieName]["Color"]["R"],
                            "G" => $Data["Series"][$SerieName]["Color"]["G"],
                            "B" => $Data["Series"][$SerieName]["Color"]["B"],
                            "Alpha" => $Data["Series"][$SerieName]["Color"]["Alpha"]
                        ];
                        if (count($SeriesName) == 1
                            && isset($Data["Series"][$SerieName]["XOffset"])
                        ) {
                            $SerieOffset = $Data["Series"][$SerieName]["XOffset"];
                        } else {
                            $SerieOffset = 0;
                        }
                        $Value = $Data["Series"][$SerieName]["Data"][$Index];
                        if ($Value == VOID) {
                            $Value = "NaN";
                        }

                        if ($ForceLabels != null) {
                            $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";
                        } else {
                            $Caption = $this->scaleFormat($Value, $AxisMode, $AxisFormat, $AxisUnit);
                        }

                        if ($this->LastChartLayout == CHART_LAST_LAYOUT_STACKED) {
                            if ($Value >= 0) {
                                $LookFor = "+";
                            } else {
                                $LookFor = "-";
                            }

                            $Value = 0;
                            $Done = false;
                            foreach ($Data["Series"] as $Name => $SerieLookup) {
                                if ($SerieLookup["isDrawable"] == true
                                    && $Name != $Data["Abscissa"] && !$Done
                                ) {
                                    if (isset($Data["Series"][$Name]["Data"][$Index])
                                        && $Data["Series"][$Name]["Data"][$Index] != VOID
                                    ) {
                                        if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+") {
                                            $Value = $Value + $Data["Series"][$Name]["Data"][$Index];
                                        }
                                        if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-") {
                                            $Value = $Value - $Data["Series"][$Name]["Data"][$Index];
                                        }
                                        if ($Name == $SerieName) {
                                            $Done = true;
                                        }
                                    }
                                }
                            }
                        }

                        $X = floor($this->GraphAreaX1 + $XMargin + $Index * $XStep + $SerieOffset);
                        $Y = floor($this->scaleComputeY($Value, ["AxisID" => $AxisID]));

                        if ($Y < $MinY) {
                            $MinY = $Y;
                        }

                        if ($DrawPoint == LABEL_POINT_CIRCLE) {
                            $this->drawFilledCircle(
                                $X,
                                $Y,
                                3,
                                [
                                    "R" => 255,
                                    "G" => 255,
                                    "B" => 255,
                                    "BorderR" => 0,
                                    "BorderG" => 0,
                                    "BorderB" => 0
                                ]
                            );
                        } elseif ($DrawPoint == LABEL_POINT_BOX) {
                            $this->drawFilledRectangle(
                                $X - 2,
                                $Y - 2,
                                $X + 2,
                                $Y + 2,
                                [
                                    "R" => 255,
                                    "G" => 255,
                                    "B" => 255,
                                    "BorderR" => 0,
                                    "BorderG" => 0,
                                    "BorderB" => 0
                                ]
                            );
                        }
                        $Series[] = ["Format" => $Serie, "Caption" => $Caption];
                    }
                }
                $this->drawLabelBox($X, $MinY - 3, $Description, $Series, $Format);
            } else {
                if ($XDivs == 0) {
                    $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1) / 4;
                } else {
                    $XStep = ($this->GraphAreaY2 - $this->GraphAreaY1 - $XMargin * 2) / $XDivs;
                }
                $Y = $this->GraphAreaY1 + $XMargin + $Index * $XStep;

                if ($DrawVerticalLine) {
                    $this->drawLine(
                        $this->GraphAreaX1 + $Data["YMargin"],
                        $Y,
                        $this->GraphAreaX2 - $Data["YMargin"],
                        $Y,
                        [
                            "R" => $VerticalLineR,
                            "G" => $VerticalLineG,
                            "B" => $VerticalLineB,
                            "Alpha" => $VerticalLineAlpha,
                            "Ticks" => $VerticalLineTicks
                        ]
                    );
                }

                $MinX = $this->GraphAreaX2;
                foreach ($SeriesName as $Key => $SerieName) {
                    if (isset($Data["Series"][$SerieName]["Data"][$Index])) {
                        $AxisID = $Data["Series"][$SerieName]["Axis"];
                        $XAxisMode = $Data["XAxisDisplay"];
                        $XAxisFormat = $Data["XAxisFormat"];
                        $XAxisUnit = $Data["XAxisUnit"];
                        $AxisMode = $Data["Axis"][$AxisID]["Display"];
                        $AxisFormat = $Data["Axis"][$AxisID]["Format"];
                        $AxisUnit = $Data["Axis"][$AxisID]["Unit"];
                        $XLabel = "";

                        if (isset($Data["Abscissa"])
                            && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])
                        ) {
                            $XLabel = $this->scaleFormat(
                                $Data["Series"][$Data["Abscissa"]]["Data"][$Index],
                                $XAxisMode,
                                $XAxisFormat,
                                $XAxisUnit
                            );
                        }

                        if ($OverrideTitle != null) {
                            $Description = $OverrideTitle;
                        } elseif (count($SeriesName) == 1) {
                            if (isset($Data["Abscissa"])
                                && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])
                            ) {
                                $Description = $Data["Series"][$SerieName]["Description"] . " - " . $XLabel;
                            }
                        } elseif (isset($Data["Abscissa"])
                            && isset($Data["Series"][$Data["Abscissa"]]["Data"][$Index])
                        ) {
                            $Description = $XLabel;
                        }
                        $Serie = [];
                        if (isset($Data["Extended"]["Palette"][$Index])) {
                            $Serie["R"] = $Data["Extended"]["Palette"][$Index]["R"];
                            $Serie["G"] = $Data["Extended"]["Palette"][$Index]["G"];
                            $Serie["B"] = $Data["Extended"]["Palette"][$Index]["B"];
                            $Serie["Alpha"] = $Data["Extended"]["Palette"][$Index]["Alpha"];
                        } else {
                            $Serie["R"] = $Data["Series"][$SerieName]["Color"]["R"];
                            $Serie["G"] = $Data["Series"][$SerieName]["Color"]["G"];
                            $Serie["B"] = $Data["Series"][$SerieName]["Color"]["B"];
                            $Serie["Alpha"] = $Data["Series"][$SerieName]["Color"]["Alpha"];
                        }

                        if (count($SeriesName) == 1 && isset($Data["Series"][$SerieName]["XOffset"])) {
                            $SerieOffset = $Data["Series"][$SerieName]["XOffset"];
                        } else {
                            $SerieOffset = 0;
                        }

                        $Value = $Data["Series"][$SerieName]["Data"][$Index];
                        if ($ForceLabels != null) {
                            $Caption = isset($ForceLabels[$Key]) ? $ForceLabels[$Key] : "Not set";
                        } else {
                            $Caption = $this->scaleFormat($Value, $AxisMode, $AxisFormat, $AxisUnit);
                        }
                        if ($Value == VOID) {
                            $Value = "NaN";
                        }

                        if ($this->LastChartLayout == CHART_LAST_LAYOUT_STACKED) {
                            if ($Value >= 0) {
                                $LookFor = "+";
                            } else {
                                $LookFor = "-";
                            }

                            $Value = 0;
                            $Done = false;
                            foreach ($Data["Series"] as $Name => $SerieLookup) {
                                if ($SerieLookup["isDrawable"] == true
                                    && $Name != $Data["Abscissa"]
                                    && !$Done
                                ) {
                                    if (isset($Data["Series"][$Name]["Data"][$Index])
                                        && $Data["Series"][$Name]["Data"][$Index] != VOID
                                    ) {
                                        if ($Data["Series"][$Name]["Data"][$Index] >= 0 && $LookFor == "+") {
                                            $Value = $Value + $Data["Series"][$Name]["Data"][$Index];
                                        }
                                        if ($Data["Series"][$Name]["Data"][$Index] < 0 && $LookFor == "-") {
                                            $Value = $Value - $Data["Series"][$Name]["Data"][$Index];
                                        }
                                        if ($Name == $SerieName) {
                                            $Done = true;
                                        }
                                    }
                                }
                            }
                        }

                        $X = floor($this->scaleComputeY($Value, ["AxisID" => $AxisID]));
                        $Y = floor($this->GraphAreaY1 + $XMargin + $Index * $XStep + $SerieOffset);

                        if ($X < $MinX) {
                            $MinX = $X;
                        }

                        if ($DrawPoint == LABEL_POINT_CIRCLE) {
                            $this->drawFilledCircle(
                                $X,
                                $Y,
                                3,
                                [
                                    "R" => 255,
                                    "G" => 255,
                                    "B" => 255,
                                    "BorderR" => 0,
                                    "BorderG" => 0,
                                    "BorderB" => 0
                                ]
                            );
                        } elseif ($DrawPoint == LABEL_POINT_BOX) {
                            $this->drawFilledRectangle(
                                $X - 2,
                                $Y - 2,
                                $X + 2,
                                $Y + 2,
                                [
                                    "R" => 255,
                                    "G" => 255,
                                    "B" => 255,
                                    "BorderR" => 0,
                                    "BorderG" => 0,
                                    "BorderB" => 0
                                ]
                            );
                        }
                        $Series[] = ["Format" => $Serie, "Caption" => $Caption];
                    }
                }
                $this->drawLabelBox($MinX, $Y - 3, $Description, $Series, $Format);
            }
        }
    }

    /**
     * @param GdImage|resource $image
     * @param array $points
     * @param int $numPoints
     * @param int $color
     * @return void
     */
    protected function imageFilledPolygonWrapper(
        $image,
        array $points,
        $numPoints,
        $color
    ) {
        if (version_compare(PHP_VERSION, '8.1.0') === -1) {
            imagefilledpolygon($image, $points, $numPoints, $color);
        } else {
            imagefilledpolygon($image, $points, $color);
        }
    }
}
