<?php

namespace Kanboard\Plugin\OrganonTweaks\Filter;

use Kanboard\Core\Filter\FilterInterface;
use Kanboard\Filter\BaseFilter;
use Kanboard\Model\TaskModel;
use PicoDb\Database;

/**
 * Filter tasks by recurrence: `recurring:XY`, one attribute with one composite value so it can
 * INTERSECT the two axes (stacking two values of the same attribute would only OR them).
 *
 *   X = system : evt (event-triggered = Kanboard native) | cal (calendar = RecoReco) | any
 *   Y = role   : ori (original/template) | dup (duplicate/copy) | all
 *
 * Conditions are authoritative -- taken straight from how core classifies these cards:
 *   - evtori = recurrence_status PENDING, evtdup = recurrence_status PROCESSED. This is exactly how
 *     core colors the board refresh icon (app/Template/board/task_footer.php: normal icon = PENDING,
 *     fa-inverse = PROCESSED), so the filter matches what the board shows.
 *   - calori = RecoReco metadata recoreco_enabled=1, caldup = recoreco_clone=1.
 *   - *all / any* = the OR-unions of the above.
 *
 * Cross-plugin: the calendar side reads RecoReco metadata keys. If RecoReco is not installed the
 * metadata sets are empty, so `cal*` matches nothing and `evt*` still works (event-only degrade).
 *
 * One attribute + one value -> single-value path, so the predicates below are grouped in a scoped
 * beginOr/closeOr and the whole group still ANDs with any other search attribute.
 */
class TaskRecurringFilter extends BaseFilter implements FilterInterface
{
    private $db;

    public function setDatabase(Database $db)
    {
        $this->db = $db;
        return $this;
    }

    public function getAttributes()
    {
        return array('recurring');
    }

    public function apply()
    {
        $value = strtolower(trim((string) $this->value));
        $system = substr($value, 0, 3); // evt | cal | any
        $role = substr($value, 3, 3);   // ori | dup | all

        if (! in_array($system, array('evt', 'cal', 'any'), true) ||
            ! in_array($role, array('ori', 'dup', 'all'), true)) {
            return $this; // unknown/typo value -> no-op
        }

        $wantEvt = $system === 'evt' || $system === 'any';
        $wantCal = $system === 'cal' || $system === 'any';
        $wantOri = $role === 'ori' || $role === 'all';
        $wantDup = $role === 'dup' || $role === 'all';

        $this->query->beginOr();

        if ($wantEvt && $wantOri) {
            $this->query->eq(TaskModel::TABLE.'.recurrence_status', TaskModel::RECURRING_STATUS_PENDING);
        }

        if ($wantEvt && $wantDup) {
            $this->query->eq(TaskModel::TABLE.'.recurrence_status', TaskModel::RECURRING_STATUS_PROCESSED);
        }

        if ($wantCal && $wantOri) {
            $this->query->in(TaskModel::TABLE.'.id', $this->metaIds('recoreco_enabled'));
        }

        if ($wantCal && $wantDup) {
            $this->query->in(TaskModel::TABLE.'.id', $this->metaIds('recoreco_clone'));
        }

        $this->query->closeOr();

        return $this;
    }

    /**
     * Task ids carrying a RecoReco metadata flag set to 1. Returns a non-matching sentinel when the
     * set is empty so the IN clause matches nothing (RecoReco absent -> event-only degrade).
     *
     * @param  string $name
     * @return array
     */
    private function metaIds($name)
    {
        $ids = $this->db->table('task_has_metadata')
            ->eq('name', $name)
            ->eq('value', '1')
            ->findAllByColumn('task_id');

        return ! empty($ids) ? $ids : array(-1);
    }
}