<?php

/*
 * © 2016 IRSTEA
 * Guillaume Perréal <guillaume.perreal@irstea.fr>
 * Tous droits réservés.
 */

namespace Irstea\PlantUmlBundle\DependencyInjection\Builder;

use Irstea\PlantUmlBundle\Model\Filter\ClassFilter;
use Irstea\PlantUmlBundle\Model\Filter\Composite\AllFilter;
use Irstea\PlantUmlBundle\Model\Filter\DirectoryFilter;
use Irstea\PlantUmlBundle\Model\Filter\NamespaceFilter;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Reference;

/**
 * Description of ClassFilterBuilder
 *
 * @author Guillaume Perréal <guillaume.perreal@irstea.fr>
 */
class ClassFilterBuilder
{
    /**
     * @var ContainerBuilder
     */
    private $container;

    /**
     * @var Reference[]
     */
    private $filters = [];

    /**
     * @var string[]
     */
    static private $filterClasses = [
        'classes'     => ClassFilter::class,
        'directories' => DirectoryFilter::class,
        'namespaces'  => NamespaceFilter::class
    ];

    /**
     * @param \Irstea\PlantUmlBundle\DependencyInjection\Builder\ContainerBuilder $container
     */
    public function __construct(ContainerBuilder $container)
    {
        $this->container = $container;
    }

    /**
     * @param array $config
     * @return Reference
     */
    public function build(array $config)
    {
        $filters = $this->normalize(array_intersect_key($config, ['include' => true, 'exclude' => true]));
        if ($filters === null) {
            return null;
        }

        $hash = sha1(serialize($filters));
        if (!key_exists($hash, $this->filters)) {
            return $this->filters[$hash] = $this->doBuild("irstea.plant_uml.filters.$hash", $filters);
        }

        return $this->filters[$hash];
    }

    /**
     * @param mixed $data
     * @return mixed
     */
    protected function normalize($data)
    {
        if ($data === null || $data === []) {
            return null;
        }
        if (is_array($data)) {
            $res = [];
            foreach($data as $k => $v) {
                $normalized = $this->normalize($v);
                if (!empty($normalized)) {
                    $res[$k] = $normalized;
                }
            }
            return empty($res) ? null : $res;
        }
        return $data;
    }

    /**
     * @param type $id
     * @param array $config
     * @return Reference
     */
    protected function doBuild($id, array $config)
    {
        $filters = [];

        if (isset($config['include'])) {
            $this->buildSubFilter($filters, "$id.include", $config['include'], false);
        }
        if (isset($config['exclude'])) {
            $this->buildSubFilter($filters, "$id.exclude", $config['exclude'], true);
        }

        if (empty($filters)) {
            return null;
        }

        if (count($filters) === 1) {
            return $filters[0];
        }

        $this->container->setDefinition($id, new Definition(AllFilter::class, [$filters]));
        return new Reference($id);
    }

    /**
     * @param array $filters
     * @param string $id
     * @param array $config
     * @param bool $notFound
     */
    protected function buildSubFilter(array &$filters, $id, array $config, $notFound)
    {
        foreach (self::$filterClasses as $key => $class) {
            if (!isset($config[$key])) {
                continue;
            }
            $subId = "$id.$key";
            $def = new Definition($class, [$config[$key], $notFound]);
            $this->container->setDefinition($subId, $def);
            $filters[] = new Reference($subId);
        }
    }
}