<?php
/*
 * This file is part of Phraseanet
 *
 * (c) 2005-2016 Alchemy
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

use Alchemy\Phrasea\Media\Subdef\Audio;
use Alchemy\Phrasea\Media\Subdef\FlexPaper;
use Alchemy\Phrasea\Media\Subdef\Gif;
use Alchemy\Phrasea\Media\Subdef\Image;
use Alchemy\Phrasea\Media\Subdef\Pdf;
use Alchemy\Phrasea\Media\Subdef\Subdef as SubdefSpecs;
use Alchemy\Phrasea\Media\Subdef\Unknown;
use Alchemy\Phrasea\Media\Subdef\Video;
use Alchemy\Phrasea\Media\Type\Type as SubdefType;
use MediaAlchemyst\Specification\SpecificationInterface;
use Symfony\Component\Translation\TranslatorInterface;

class databox_subdef
{
    /** @var databox|null  */
    private $databox;

    /**
     * The class type of the subdef
     * Is null or one of the CLASS_* constants
     *
     * @var string
     */
    protected $class;
    protected $devices = [];
    protected $name;
    protected $path;
    protected $preset;
    protected $subdef_group;
    protected $labels = [];
    /**
     * @var bool
     */
    private $requiresMetadataUpdate;
    protected $downloadable;
    protected $orderable;
    protected $substituable;
    protected $tobuild;
    protected $translator;
    protected static $mediaTypeToSubdefTypes = [
        SubdefType::TYPE_AUDIO    => [SubdefSpecs::TYPE_IMAGE, SubdefSpecs::TYPE_AUDIO],
        SubdefType::TYPE_DOCUMENT => [SubdefSpecs::TYPE_IMAGE, SubdefSpecs::TYPE_FLEXPAPER, SubdefSpecs::TYPE_PDF],
        SubdefType::TYPE_FLASH    => [SubdefSpecs::TYPE_IMAGE],
        SubdefType::TYPE_IMAGE    => [SubdefSpecs::TYPE_IMAGE, SubdefSpecs::TYPE_PDF],
        SubdefType::TYPE_VIDEO    => [SubdefSpecs::TYPE_IMAGE, SubdefSpecs::TYPE_VIDEO, SubdefSpecs::TYPE_ANIMATION, SubdefSpecs::TYPE_AUDIO],
        SubdefType::TYPE_UNKNOWN  => [SubdefSpecs::TYPE_IMAGE],
    ];
    const CLASS_THUMBNAIL = 'thumbnail';
    const CLASS_PREVIEW = 'preview';
    const CLASS_DOCUMENT = 'document';
    const DEVICE_ALL = 'all';
    const DEVICE_HANDHELD = 'handheld';
    const DEVICE_PRINT = 'print';
    const DEVICE_PROJECTION = 'projection';
    const DEVICE_SCREEN = 'screen';
    const DEVICE_TV = 'tv';

    /**
     *
     * @param SubdefType $type
     * @param SimpleXMLElement $sd
     * @param TranslatorInterface $translator
     * @param databox|null $databox
     */
    public function __construct(SubdefType $type, SimpleXMLElement $sd, TranslatorInterface $translator, databox $databox = null)
    {
        $this->databox = $databox;
        $this->subdef_group = $type;
        $this->class = (string)$sd->attributes()->class;
        $this->translator = $translator;
        foreach ($sd->devices as $device) {
            $this->devices[] = (string)$device;
        }
        $this->name = strtolower($sd->attributes()->name);
        $this->downloadable = p4field::isyes($sd->attributes()->downloadable);
        $this->substituable = isset($sd->attributes()->substituable) && p4field::isyes($sd->attributes()->substituable);
        $this->orderable = !isset($sd->attributes()->orderable) || p4field::isyes($sd->attributes()->orderable);
        $this->tobuild = !isset($sd->attributes()->tobuild) || p4field::isyes($sd->attributes()->tobuild);
        $this->path = trim($sd->path) !== '' ? p4string::addEndSlash(trim($sd->path)) : '';
        $this->preset = $sd->attributes()->presets;
        $this->requiresMetadataUpdate = p4field::isyes((string)$sd->meta);
        foreach ($sd->label as $label) {
            $lang = trim((string)$label->attributes()->lang);
            if ($lang) {
                $this->labels[$lang] = (string)$label;
            }
        }
        switch ((string)$sd->mediatype) {
            default:
            case SubdefSpecs::TYPE_IMAGE:
                $this->subdef_type = $this->buildImageSubdef($sd);
                break;
            case SubdefSpecs::TYPE_AUDIO:
                $this->subdef_type = $this->buildAudioSubdef($sd);
                break;
            case SubdefSpecs::TYPE_VIDEO:
                $this->subdef_type = $this->buildVideoSubdef($sd);
                break;
            case SubdefSpecs::TYPE_ANIMATION:
                $this->subdef_type = $this->buildGifSubdef($sd);
                break;
            case SubdefSpecs::TYPE_FLEXPAPER:
                $this->subdef_type = $this->buildFlexPaperSubdef($sd);
                break;
            case SubdefSpecs::TYPE_PDF:
                $this->subdef_type = $this->buildPdfSubdef($sd);
                break;
            case SubdefSpecs::TYPE_UNKNOWN:
                $this->subdef_type = $this->buildImageSubdef($sd);
                break;
        }
    }

    public function getDatabox()
    {
        return $this->databox;
    }

    /**
     * Build Image Subdef object depending the SimpleXMLElement
     *
     * @param  SimpleXMLElement $sd
     * @return Image
     */
    protected function buildImageSubdef(SimpleXMLElement $sd)
    {
        $image = new Image($this->translator);
        if ($sd->icodec) {
            $image->setOptionValue(Image::OPTION_ICODEC, (string) $sd->icodec);
        }
        if ($sd->size) {
            $image->setOptionValue(Image::OPTION_SIZE, (int) $sd->size);
        }
        if ($sd->quality) {
            $image->setOptionValue(Image::OPTION_QUALITY, (int) $sd->quality);
        }
        if ($sd->strip) {
            $image->setOptionValue(Image::OPTION_STRIP, p4field::isyes($sd->strip));
        }
        if ($sd->dpi) {
            $image->setOptionValue(Image::OPTION_RESOLUTION, (int) $sd->dpi);
        }
        if ($sd->flatten) {
            $image->setOptionValue(Image::OPTION_FLATTEN, p4field::isyes($sd->flatten));
        }
        if ($sd->watermark) {
            $image->setOptionValue(Image::OPTION_WATERMARK, (string) $sd->watermark);
        }
        if ($sd->watermarktext) {
            $image->setOptionValue(Image::OPTION_WATERMARKTEXT, $sd->watermarktext);
        }
        if ($sd->watermarkrid) {
            $image->setOptionValue(Image::OPTION_WATERMARKRID, $sd->watermarkrid);
        }
        if ($sd->backgroundcolor) {
            $image->setOptionValue(Image::OPTION_BACKGROUNDCOLOR, $sd->backgroundcolor);
        }
        return $image;
    }
    /**
     * Build Audio Subdef object depending the SimpleXMLElement
     *
     * @param  SimpleXMLElement $sd
     * @return Audio
     */
    protected function buildAudioSubdef(SimpleXMLElement $sd)
    {
        $audio = new Audio($this->translator);
        if ($sd->acodec) {
            $audio->setOptionValue(Audio::OPTION_ACODEC, (string) $sd->acodec);
        }
        if ($sd->audiobitrate) {
            $audio->setOptionValue(Audio::OPTION_AUDIOBITRATE, (int) $sd->audiobitrate);
        }
        if ($sd->audiosamplerate) {
            $audio->setOptionValue(Audio::OPTION_AUDIOSAMPLERATE, (int) $sd->audiosamplerate);
        }
        if ($sd->audiochannel) {
            $audio->setOptionValue(Audio::OPTION_AUDIOCHANNEL, (string) $sd->audiochannel);
        }

        return $audio;
    }
    /**
     * Build Video Subdef object depending the SimpleXMLElement
     *
     * @param  SimpleXMLElement $sd
     * @return Video
     */
    protected function buildVideoSubdef(SimpleXMLElement $sd)
    {
        $video = new Video($this->translator);
        if ($sd->size) {
            $video->setOptionValue(Video::OPTION_SIZE, (int) $sd->size);
        }
        if ($sd->acodec) {
            $video->setOptionValue(Video::OPTION_ACODEC, (string) $sd->acodec);
        }
        if ($sd->vcodec) {
            $video->setOptionValue(Video::OPTION_VCODEC, (string) $sd->vcodec);
        }
        if ($sd->fps) {
            $video->setOptionValue(Video::OPTION_FRAMERATE, (int) $sd->fps);
        }
        if ($sd->bitrate) {
            $video->setOptionValue(Video::OPTION_BITRATE, (int) $sd->bitrate);
        }
        if ($sd->audiobitrate) {
            $video->setOptionValue(Video::OPTION_AUDIOBITRATE, (int) $sd->audiobitrate);
        }
        if ($sd->audiosamplerate) {
            $video->setOptionValue(Video::OPTION_AUDIOSAMPLERATE, (int) $sd->audiosamplerate);
        }
        if ($sd->GOPsize) {
            $video->setOptionValue(Video::OPTION_GOPSIZE, (int) $sd->GOPsize);
        }
        return $video;
    }
    /**
     * Build GIF Subdef object depending the SimpleXMLElement
     *
     * @param  SimpleXMLElement $sd
     * @return Gif
     */
    protected function buildGifSubdef(SimpleXMLElement $sd)
    {
        $gif = new Gif($this->translator);
        if ($sd->size) {
            $gif->setOptionValue(Gif::OPTION_SIZE, (int) $sd->size);
        }
        if ($sd->delay) {
            $gif->setOptionValue(Gif::OPTION_DELAY, (int) $sd->delay);
        }
        return $gif;
    }
    /**
     * Build Flexpaper Subdef object depending the SimpleXMLElement
     *
     * @param  SimpleXMLElement $sd
     * @return FlexPaper
     */
    protected function buildFlexPaperSubdef(SimpleXMLElement $sd)
    {
        return new FlexPaper($this->translator);
    }
    /**
     * Build Pdf Subdef object depending the SimpleXMLElement
     *
     * @param  SimpleXMLElement $sd
     * @return Pdf
     */
    protected function buildPdfSubdef(SimpleXMLElement $sd)
    {
        return new Pdf($this->translator);
    }
    /**
     *
     * @return string
     */
    public function get_class()
    {
        return $this->class;
    }

    /**
     *
     * @return string
     */
    public function get_preset()
    {
        return $this->preset;
    }

    /**
     *
     * @return string
     */
    public function get_path()
    {
        return $this->path;
    }

    /**
     * The devices matching this subdefinition
     *
     * @return Array
     */
    public function getDevices()
    {
        return $this->devices;
    }

    /**
     * The current SubdefType the subdef converts documents
     *
     * @return Alchemy\Phrasea\Media\Subdef\Subdef
     */
    public function getSubdefType()
    {
        return $this->subdef_type;
    }

    /**
     * The current Group which the subdef is in (Audio, Video ...)
     *
     * @return Alchemy\Phrasea\Media\Type\Type
     */
    public function getSubdefGroup()
    {
        return $this->subdef_group;
    }

    /**
     * An associative label ; keys are i18n languages
     *
     * @return Array
     */
    public function get_labels()
    {
        return $this->labels;
    }

    public function get_label($code, $substitute = true)
    {
        if (empty($this->labels[$code]) && $substitute) {
            return $this->get_name();
        } elseif (isset($this->labels[$code])) {
            return $this->labels[$code];
        }
        return null;
    }

    /**
     * boolean
     *
     * @return bool
     */
    public function isDownloadable()
    {
        return $this->downloadable;
    }
    
    /**
     * @Deprecated (alias done cause of webgallery usage of old function)
     *
     * boolean
     *
     * @return bool
     */
    public function is_downloadable()
    {
        return $this->isDownloadable();
    }

    /**
     * @return bool
     */
    public function isOrderable()
    {
        return $this->orderable;
    }

    /**
     * @return bool
     */
    public function isTobuild()
    {
        return $this->tobuild;
    }

    /**
     * @return bool
     */
    public function isSubstituable()
    {
        return $this->substituable;
    }

    /**
     * Get an array of Alchemy\Phrasea\Media\Subdef\Subdef available for the current Media Type
     *
     * @return array
     */
    public function getAvailableSubdefTypes()
    {
        $subdefTypes = [];
        $availableDevices = [
            self::DEVICE_ALL,
            self::DEVICE_HANDHELD,
            self::DEVICE_PRINT,
            self::DEVICE_PROJECTION,
            self::DEVICE_SCREEN,
            self::DEVICE_TV,
        ];
        if (isset(self::$mediaTypeToSubdefTypes[$this->subdef_group->getType()])) {
            foreach (self::$mediaTypeToSubdefTypes[$this->subdef_group->getType()] as $subdefType) {
                if ($subdefType == $this->subdef_type->getType()) {
                    $mediatype_obj = $this->subdef_type;
                } else {
                    switch ($subdefType) {
                        case SubdefSpecs::TYPE_ANIMATION:
                            $mediatype_obj = new Gif($this->translator);
                            break;
                        case SubdefSpecs::TYPE_AUDIO:
                            $mediatype_obj = new Audio($this->translator);
                            break;
                        case SubdefSpecs::TYPE_FLEXPAPER:
                            $mediatype_obj = new FlexPaper($this->translator);
                            break;
                        case SubdefSpecs::TYPE_IMAGE:
                            $mediatype_obj = new Image($this->translator);
                            break;
                        case SubdefSpecs::TYPE_VIDEO:
                            $mediatype_obj = new Video($this->translator);
                            break;
                        case SubdefSpecs::TYPE_PDF:
                            $mediatype_obj = new Pdf($this->translator);
                            break;
                        case SubdefSpecs::TYPE_UNKNOWN:
                            $mediatype_obj = new Unknown($this->translator);
                            break;
                        default:
                            continue;
                            break;
                    }
                }
                $mediatype_obj->registerOption(new \Alchemy\Phrasea\Media\Subdef\OptionType\Multi($this->translator->trans('Target Device'),
                    'devices', $availableDevices, $this->devices));
                $subdefTypes[] = $mediatype_obj;
            }
        }
        return $subdefTypes;
    }

    /**
     * Tells us if we have to write meta data in the subdef
     *
     * @return bool
     */
    public function isMetadataUpdateRequired()
    {
        return $this->requiresMetadataUpdate;
    }

    /**
     * The name of the subdef
     *
     * @return string
     */
    public function get_name()
    {
        return $this->name;
    }

    /**
     * Get the MediaAlchemyst specs for the current subdef
     *
     * @return SpecificationInterface
     */
    public function getSpecs()
    {
        return $this->subdef_type->getMediaAlchemystSpec();
    }

    /**
     * An array of Alchemy\Phrasea\Media\Subdef\OptionType\OptionType for the current subdef
     *
     * @return array
     */
    public function getOptions()
    {
        return $this->subdef_type->getOptions();
    }
}
