AlecRabbit\Counters\VolumeCounter

Complexity

Total Complexity

29

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Test Coverage

Coverage

98.61%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	processPart()	0	20	1
A	trim()	0	9	6
A	getRawData()	0	6	1
A	addTrade()	0	12	3
A	getEventsArray()	0	14	5
A	reset()	0	4	1
F	getVolumeArray()	0	38	12

<?php
/**
 * User: alec
 * Date: 19.11.18
 * Time: 17:27
 */
declare(strict_types=1);

namespace AlecRabbit\Counters;

use AlecRabbit\Structures\Trade;

class VolumeCounter extends EventsCounter
{
    protected const DOMAINS = [
        STR_TOTAL,
        STR_SELL,
        STR_BUY,
        STR_VP_TOTAL,
        STR_VP_SELL,
        STR_VP_BUY,
        STR_P_SUM_TOTAL,
        STR_P_SUM_SELL,
        STR_P_SUM_BUY,
    ];

    /** @var array */
    protected $volumes = [];

    public function addTrade(Trade $trade): void
    {
        $baseTimes = $this->getBaseTimes($trade->timestamp);
        $volumePrice = $trade->amount * $trade->price;
        foreach ($baseTimes as $period => $timestamp) {
            $this->processPart(STR_TOTAL, $period, $timestamp, $volumePrice, $trade);
            if ($trade->side === T_SELL) {
                $this->processPart(STR_SELL, $period, $timestamp, $volumePrice, $trade);
            } else {
                $this->processPart(STR_BUY, $period, $timestamp, $volumePrice, $trade);
            }
            $this->trim($period);
        }
    }

    /**
     * @param string $subdomain
     * @param int $period
     * @param int $timestamp
     * @param float $volumePrice
     * @param Trade $trade
     */
    protected function processPart(
        string $subdomain,
        int $period,
        int $timestamp,
        float $volumePrice,
        Trade $trade
    ): void {
        $this->volumes[STR_VP . $subdomain][$period][$timestamp] =
            $this->volumes[STR_VP . $subdomain][$period][$timestamp] ?? 0;
        $this->volumes[STR_VP . $subdomain][$period][$timestamp] += $volumePrice;

        $this->volumes[STR_P_SUM . $subdomain][$period][$timestamp] =
            $this->volumes[STR_P_SUM . $subdomain][$period][$timestamp] ?? 0;
        $this->volumes[STR_P_SUM . $subdomain][$period][$timestamp] += $trade->price;

        $this->volumes[$subdomain][$period][$timestamp] = $this->volumes[$subdomain][$period][$timestamp] ?? 0;
        $this->volumes[$subdomain][$period][$timestamp] += $trade->amount;

        $this->data[$subdomain][$period][$timestamp] = $this->data[$subdomain][$period][$timestamp] ?? 0;
        $this->data[$subdomain][$period][$timestamp]++;
    }

    /**
     * @param int $period
     */
    protected function trim(int $period): void
    {
        $threshold = $this->getThreshold($period);
        foreach (static::DOMAINS as $domain) {
            if (null !== ($key = array_key_first($this->data[$domain][$period] ?? [])) && ($key <= $threshold)) {
                unset($this->data[$domain][$period][$key]);
            }
            if (null !== ($key = array_key_first($this->volumes[$domain][$period] ?? [])) && ($key <= $threshold)) {
                unset($this->volumes[$domain][$period][$key]);
            }
        }
    }

    /**
     * @param bool|null $reset
     * @return array
     */
    public function getVolumeArray(?bool $reset = null): array
    {
        $volume = [];
        foreach (static::DOMAINS as $domain) {
            foreach ($this->periods as $period => $groupBy) {
                if (0 < ($sum = array_sum($this->volumes[$domain][$period] ?? []))) {
                    $volume[$domain][$period] = $sum;
                }
            }
        }
        $events = $this->getEventsArray();
        foreach ($this->periods as $period => $groupBy) {
            if (isset($volume[STR_VP_TOTAL][$period], $volume[STR_TOTAL][$period])) {
                $volume[STR_VWAP_TOTAL][$period] = $volume[STR_VP_TOTAL][$period] / $volume[STR_TOTAL][$period];
            }
            if (isset($volume[STR_VP_SELL][$period], $volume[STR_SELL][$period])) {
                $volume[STR_VWAP_SELL][$period] = $volume[STR_VP_SELL][$period] / $volume[STR_SELL][$period];
            }
            if (isset($volume[STR_VP_BUY][$period], $volume[STR_BUY][$period])) {
                $volume[STR_VWAP_BUY][$period] = $volume[STR_VP_BUY][$period] / $volume[STR_BUY][$period];
            }
            if (isset($volume[STR_P_SUM_TOTAL][$period], $events[STR_TOTAL][$period])) {
                $volume[STR_AVG_PRICE_TOTAL][$period] =
                    $volume[STR_P_SUM_TOTAL][$period] / $events[STR_TOTAL][$period];
            }
            if (isset($volume[STR_P_SUM_SELL][$period], $events[STR_SELL][$period])) {
                $volume[STR_AVG_PRICE_SELL][$period] =
                    $volume[STR_P_SUM_SELL][$period] / $events[STR_SELL][$period];
            }
            if (isset($volume[STR_P_SUM_BUY][$period], $events[STR_BUY][$period])) {
                $volume[STR_AVG_PRICE_BUY][$period] =
                    $volume[STR_P_SUM_BUY][$period] / $events[STR_BUY][$period];
            }
        }
        if ($reset) {
            $this->reset();
        }
        return $volume;
    }

    /**
     * @inheritDoc
     */
    public function getEventsArray(?bool $reset = null): array
    {
        $events = [];
        foreach (static::DOMAINS as $domain) {
            foreach ($this->periods as $period => $groupBy) {
                if (0 < ($sum = array_sum($this->data[$domain][$period] ?? []))) {
                    $events[$domain][$period] = $sum;
                }
            }
        }
        if ($reset) {
            $this->reset();
        }
        return $events;
    }

    /**
     * @inheritDoc
     */
    protected function reset(): void
    {
        $this->data = [];
        $this->volumes = [];
    }

    /** @return array */
    public function getRawData(): array
    {
        return
            [
                STR_VOLUMES => $this->volumes,
                STR_EVENTS => parent::getRawData(),
            ];
    }
}