<?php
namespace App\Komma\Shop\Products\ProductGroup;

use App\Komma\Kms\Core\Attributes\Attribute;
use App\Komma\Kms\Core\Attributes\Models\SelectOption;
use App\Komma\Kms\Core\Sections\AbstractSectionTabItem;
use App\Komma\Kms\Core\Sections\SectionService;
use App\Komma\Kms\Core\Sections\SectionTabItem;
use App\Komma\Shop\Categories\Kms\CategorizableInterface;
use App\Komma\Shop\Categories\Kms\CategoryServiceInterface;
use App\Komma\Shop\Orders\Models\Order;
use App\Komma\Shop\Orders\ProductGroup\OrderedProductGroup;
use App\Komma\Shop\Products\Product\Product;
use App\Komma\Shop\Products\Product\ProductServiceInterface;
use App\Komma\Shop\Products\ProductGroupBehaviour\ProductGroupBehaviorService;
use App\Komma\Shop\Products\ProductGroupBehaviour\ProductGroupBehaviour;
use App\Komma\Shop\Properties\Kms\PropertyService;
use App\Komma\Shop\Properties\Models\PropertizableInterface;
use App\Komma\Sites\HasSitesInterface;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;

/**
 * Class ProductService
 * @package App\Komma\Shop\Products
 */
class ProductGroupService extends SectionService implements ProductGroupServiceInterface
{
    protected $sortable = false;

    /** @var ProductServiceInterface $productService  */
    private $productService;

    /** @var ProductGroupBehaviorService $productGroupBehaviourService */
    private $productGroupBehaviourService;

    /** @var CategoryServiceInterface $categoryService */
    private $categoryService;

    /** @var PropertyService $propertyService */
    private $propertyService;

    function __construct()
    {
        $this->forModelName = ProductGroup::class;
        $this->productService = app(ProductServiceInterface::class);
        $this->productGroupBehaviourService = new ProductGroupBehaviorService();
        $this->categoryService = app(CategoryServiceInterface::class);
        $this->propertyService = app(PropertyService::class);

        parent::__construct();
    }


    /**
     * This method will save an model
     *
     * @param $model Model or null
     * @param Collection $sectionTabItems These must be filled with data. This is something you need to do yourself.
     *
     * @return mixed
     */
    public function saveModel(Model $model = null, Collection $sectionTabItems): Model
    {
        /** @var ProductGroup $model */
        $sectionTabItems->each(function ($sectionTabItem, $key) use ($model) {
            /** @var SectionTabItem $sectionTabItem */

            $attribute = $sectionTabItem->getAttribute();
            $value = $attribute->getValue();

            $reference = $attribute->getsValueFromReference();
            switch ($attribute->getsValueFrom()) {
                case Attribute::ValueFromModel:
                    if ($reference == 'product_group_behaviour_id') {
                        $behaviour = ProductGroupBehaviour::find($value);
                        if ($behaviour && $model) {
                            $model->productGroupBehaviour()->associate($behaviour);
                        }
                    }
                    break;
                case Attribute::ValueFromItself:
                    if($reference == 'category_id') {
                        $this->doAfterSave(function ($model) use( $value) {
                            $this->categoryService->makeChildOfCategoriesIfNotAlready($model, $value);
                        });
                    }
                    if($reference == 'property_id')
                    {
                        $this->doAfterSave(function ($model) use( $value) {
                            $this->propertyService->linkToProperties($model, $value);
                        });
                    }
                    else if($reference == 'site_id')
                    {
                        $this->doAfterSave(function ($model) use( $value ) {
                            /** @var HasSitesInterface $model */
                            $this->siteService->linkModelToSitesUsingIdCsvString($model, $value);
                        });
                    }
            }
        });

        parent::saveModel($model, $sectionTabItems);

        return $model;
    }

    /**
     * Fills non-productGroup specific attributes. ProductGroup specific attributes are processed in the parent
     *
     *
     * @param Collection $sectionTabItems A collection containing implementations AbstractSectionTabItem's
     * @param Model $model
     * @return Collection
     */
    public function fillAttributesWithData(Collection $sectionTabItems, Model $model)
    {
        //Validate that each Collection item is an instance of AbstractSectionTabItem
        $sectionTabItems->every(function ($item, $key) {
            if (!is_a($item, AbstractSectionTabItem::class)) {
                throw new \InvalidArgumentException("The attributes passed must be a Collection of AbstractSectionTabItem instances but was not");
            }
        });

        $sectionTabItems->each(
            function ($sectionTabItem, $key) use ($model) {
                /** @var $sectionTabItem SectionTabItem */

                if (!is_a($sectionTabItem->getAttribute(), Attribute::class)) {
                    throw new \InvalidArgumentException("One of the attributes in a AbstractSectionTabItem instance is not but must be an child instance of Attribute.");
                }

                $valueReference = $sectionTabItem->getAttribute()->getsValueFromReference();

                switch($valueReference)
                {
                    case 'category_id':
                        /** @var CategorizableInterface $model */
                        $idString = $this->categoryService->getCategoryIdsForModel($model);
                        if($idString) $sectionTabItem->getAttribute()->setValue($idString);
                        break;
                    case 'property_id':
                        /** @var PropertizableInterface $model */
                        $idString = $this->propertyService->getPropertyIdsForModel($model);
                        if($idString) $sectionTabItem->getAttribute()->setValue($idString);
                        break;
                    case 'site_id':
                        /** @var HasSitesInterface $model */
                        $idString = $this->siteService->getSiteIdsForModel($model);
                        if($idString) $sectionTabItem->getAttribute()->setValue($idString);
                        break;
                }
            }
        );

        $filledAttributes = parent::fillAttributesWithData($sectionTabItems, $model);

        return $filledAttributes;
    }

    /**
     * @return SelectOption[]
     */
    public function getOptionModelsForProductSelect():array
    {
        $models = [];

        $products = $this->productService->models()->with('translation')->get();
        $products->each(function ($product) use (&$models) {
            /** @var $product Product */
            $models[] = (new SelectOption())->setValue($product->id)->setContent($product->id)->setHtmlContent($product->getSidebarName());
        });

        return $models;
    }

    /**
     * @return SelectOption[]
     */
    public function getOptionModelsForBehaviourSelect():array
    {
        $models = [];

        $behaviours = $this->productGroupBehaviourService->models()->get();
        $behaviours->each(function ($behaviour) use (&$models) {
            $models[] = (new SelectOption())->setValue($behaviour->id)->setContent($behaviour->name)->setHtmlContent(__('shop/products.'.$behaviour->name));
        });

        return $models;
    }


    /**
     * Return all groups that are not in composites
     *
     * @return Builder
     */
    public function modelsNotInComposites()
    {
        $groups = $this->models() //Get all group models
        ->doesntHave('composites') //...that are not in composites
        ->with(['translation']); //...with all groupTranslations for the current language id of the current site

        return $groups;
    }

    /**
     * Returns the price of the items in the group or the entry-level price depending on the groups behaviour.
     *
     * @param ProductGroup $group
     * @return int
     */
    public function getPrice(ProductGroup $group):int {
        /** @var ProductGroupBehaviour $behaviour */
        $behaviour = $group->productGroupBehaviour()->get();
        if(!$behaviour) return 0;

        $price = false;
        switch ($behaviour->name) {
            case 'or':
            case 'xor':
                $price = $group->products()->min('price');
                break;
            case 'and':
                $price = $group->products()->sum('price');
                break;
        }

        if($price == 0) throw new \RuntimeException('The group "'.$group->name.'" did have a non implemented behaviour name: '.$behaviour->name);
    }

    /**
     * Makes a single orderedProduct based of a product
     *
     * @param ProductGroup $productGroup
     * @param Order $order
     * @return OrderedProductGroup
     */
    public function createOrderedProductGroupFromProductGroup(ProductGroup $productGroup, Order $order)
    {
        $attributes = $productGroup->getAttributes();
        unset($attributes['product_group_behaviour_id']);
        unset($attributes['id']);

        $orderedProductGroup = new OrderedProductGroup($attributes);
        $orderedProductGroup->quantity = 1;
        $orderedProductGroup->order()->associate($order);
        $orderedProductGroup->productGroup()->associate($productGroup);
        $orderedProductGroup->save();

        $products = $productGroup->products()->get();
        $orderedProducts = $products->map(function(Product $product) use ($order) {
            return $this->productService->createOrderedProductFromProduct($product, $order);
        });


        $orderedProductGroup->products()->saveMany($products);
        $orderedProductGroup->orderedProducts()->saveMany($orderedProducts);

        return $orderedProductGroup;
    }
}