<?php
    
    namespace artbox\catalog\models;

    use artbox\catalog\behaviors\ManyToManyBehavior;
    use artbox\core\behaviors\LanguageBehavior;
    use artbox\core\models\Image;
    use artbox\core\models\Language;
    use artbox\stock\models\VariantToShop;
    use Yii;
    use yii\behaviors\TimestampBehavior;
    use yii\db\ActiveQuery;
    use yii\db\ActiveRecord;
    use yii\db\Query;
    use yii\web\Request;

    /**
     * This is the model class for table "variant".
     *
     * @property integer                       $id
     * @property integer                       $product_id
     * @property string                        $sku
     * @property float                         $price
     * @property float                         $price_old
     * @property integer                       $stock
     * @property boolean                       $status
     * @property integer                       $sort
     * @property integer                       $created_at
     * @property integer                       $updated_at
     * @property integer                       $image_id
     * @property Image                         $image
     * @property Product                       $product
     * @property VariantLang[]                 $variantLangs
     * @property Language[]                    $languages
     * @property array                         $counts
     * @property VariantToImage[]              $variantToImages
     * @property Image[]                       $images
     * @property VariantToVariantOptionCompl[] $variantToVariantOptionCompls
     * @property VariantOptionCompl[]          $variantOptionCompls
     * @property VariantToVariantOptionExcl[]  $variantToVariantOptionExcls
     * @property VariantOptionExcl[]           $variantOptionExcls
     *      * From language behavior *
     * @property VariantLang                   $lang
     * @property VariantLang[]                 $langs
     * @property VariantLang                   $objectLang
     * @property string                        $ownerKey
     * @property string                        $langKey
     * @property VariantLang[]                 $modelLangs
     * @property bool                          $transactionStatus
     * @method string           getOwnerKey()
     * @method void             setOwnerKey( string $value )
     * @method string           getLangKey()
     * @method void             setLangKey( string $value )
     * @method ActiveQuery      getLangs()
     * @method ActiveQuery      getLang( integer $language_id )
     * @method VariantLang[]    generateLangs()
     * @method void             loadLangs( Request $request )
     * @method bool             linkLangs()
     * @method bool             saveLangs()
     * @method bool             getTransactionStatus()
     * @method bool             loadWithLangs( Request $request )
     * @method bool             saveWithLangs()
     *      * End language behavior *
     * @see LanguageBehavior
     */
    class Variant extends ActiveRecord
    {
    
        protected $sortedGroups = [];
        
        /**
         * @inheritdoc
         */
        public static function tableName()
        {
            return 'variant';
        }
    
        /**
         * @inheritdoc
         */
        public function behaviors()
        {
            return [
                'language'  => [
                    'class' => LanguageBehavior::className(),
                ],
                'timestamp' => [
                    'class' => TimestampBehavior::className(),
                ],
                [
                    'class' => ManyToManyBehavior::className(),
                ],
            ];
        }
        
        /**
         * @inheritdoc
         */
        public function rules()
        {
            return [
                [
                    [
                        'sku',
                    ],
                    'required',
                ],
                [
                    [
                        'stock',
                        'sort',
                        'image_id',
                    ],
                    'integer',
                ],
                [
                    [
                        'price',
                        'price_old',
                    ],
                    'number',
                ],
                [
                    [ 'status' ],
                    'boolean',
                ],
                [
                    [ 'sku' ],
                    'string',
                    'max' => 255,
                ],
                [
                    [
                        'variantOptionCompls',
                        'variantOptionExcls',
                    ],
                    'safe',
                ],
            ];
        }
        
        /**
         * @inheritdoc
         */
        public function attributeLabels()
        {
            return [
                'id'         => Yii::t('catalog', 'ID'),
                'product_id' => Yii::t('catalog', 'Product ID'),
                'sku'        => Yii::t('catalog', 'Sku'),
                'price'      => Yii::t('catalog', 'Price'),
                'price_old'  => Yii::t('catalog', 'Price Old'),
                'stock'      => Yii::t('catalog', 'Stock'),
                'status'     => Yii::t('catalog', 'Status'),
                'sort'       => Yii::t('catalog', 'Sort'),
                'image_id'   => Yii::t('catalog', 'image_id'),
                'created_at' => Yii::t('catalog', 'Created At'),
                'updated_at' => Yii::t('catalog', 'Updated At'),
            ];
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProduct()
        {
            return $this->hasOne(Product::className(), [ 'id' => 'product_id' ])
                        ->inverseOf('variants');
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantLangs()
        {
            return $this->hasMany(VariantLang::className(), [ 'variant_id' => 'id' ])
                        ->inverseOf('variant');
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getLanguages()
        {
            return $this->hasMany(Language::className(), [ 'id' => 'language_id' ])
                        ->viaTable('variant_lang', [ 'variant_id' => 'id' ]);
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantToImages()
        {
            return $this->hasMany(VariantToImage::className(), [ 'variant_id' => 'id' ])
                        ->inverseOf('variant');
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getImages()
        {
            return $this->hasMany(Image::className(), [ 'id' => 'image_id' ])
                        ->viaTable('variant_to_image', [ 'variant_id' => 'id' ]);
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getImage()
        {
            return $this->hasOne(Image::className(), [ 'id' => 'image_id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantToVariantOptionCompls()
        {
            return $this->hasMany(VariantToVariantOptionCompl::className(), [ 'variant_id' => 'id' ])
                        ->inverseOf('variant');
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantOptionCompls()
        {
            return $this->hasMany(VariantOptionCompl::className(), [ 'id' => 'variant_option_compl_id' ])
                        ->viaTable('variant_to_variant_option_compl', [ 'variant_id' => 'id' ]);
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantToVariantOptionExcls()
        {
            return $this->hasMany(VariantToVariantOptionExcl::className(), [ 'variant_id' => 'id' ])
                        ->inverseOf('variant');
        }
        
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantOptionExcls()
        {
            return $this->hasMany(VariantOptionExcl::className(), [ 'id' => 'variant_option_excl_id' ])
                        ->viaTable('variant_to_variant_option_excl', [ 'variant_id' => 'id' ]);
        }
    
        public function getStock()
        {
            if (class_exists('\artbox\stock\models\VariantToShop')) {
                return $this->hasMany('\artbox\stock\models\VariantToShop', [ 'variant_id' => 'id' ])
                            ->inverseOf('variant');
    
            } else {
                return ( new Query() )->where('1 = 0');
            }
        }
        public function shopCount($shop_id)
        {
    
            if (class_exists('\artbox\stock\models\VariantToShop')) {
                if ($this->isNewRecord) {
                    return null;
                }
                $count = VariantToShop::find()
                                      ->where([ 'variant_id' => $this->id ])
                                      ->andWhere([ 'shop_id' => $shop_id ])
                                      ->one();
                if ($count == null) {
                    return null;
                }
                return $count->count;
            } else {
                return null;
            }
        }
    
        public function getCounts()
        {
            if (class_exists('\artbox\stock\models\VariantToShop')) {
                return $this->getVariantToShops()
                            ->select(
                                [
                                    'variant_id',
                                    'sum' => 'sum(count)',
                                ]
                            )
                            ->asArray()
                            ->groupBy('variant_id');
    
            } else {
                return $this->stock;
            }
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantToShops()
        {
            return $this->hasMany(VariantToShop::className(), [ 'variant_id' => 'id' ]);
        }
    
        /**
         * Setter for Variant Options Complementary
         *
         * @param $value
         */
        public function setVariantOptionCompls($value)
        {
            $this->variantOptionCompls = $value;
        }
    
        /**
         * Setter for Variant Options Exclusion
         *
         * @param $value
         */
        public function setVariantOptionExcls($value)
        {
            $this->variantOptionExcls = $value;
        }
    
        /**
         * Sort groups for current variant and return them
         *
         * @return array
         */
        public function getSortedGroups(): array
        {
            if (empty($this->sortedGroups)) {
                $productOptionCompls = $this->product->productOptionCompls;
                $productOptionExcls = $this->product->productOptionExcls;
                $variantOptionCompls = $this->variantOptionCompls;
                $variantOptionExcls = $this->variantOptionExcls;
                if (!empty($productOptionCompls)) {
                    $this->sortedGroups[ ProductOptionGroupCompl::className() ] = [];
                    foreach ($productOptionCompls as $option) {
                        if (empty($this->sortedGroups[ ProductOptionGroupCompl::className() ][ $option->groupId ])) {
                            $this->sortedGroups[ ProductOptionGroupCompl::className(
                            ) ][ $option->groupId ] = $option->group;
                        }
                        $option->group->currentOptions[] = $option;
                    }
                    usort(
                        $this->sortedGroups[ ProductOptionGroupCompl::className() ],
                        function ($a, $b) {
                            /**
                             * @var OptionGroup $a
                             * @var OptionGroup $b
                             */
                            return $a->sort - $b->sort;
                        }
                    );
                }
                if (!empty($productOptionExcls)) {
                    $this->sortedGroups[ ProductOptionGroupExcl::className() ] = [];
                    foreach ($productOptionExcls as $option) {
                        if (empty($this->sortedGroups[ ProductOptionGroupExcl::className() ][ $option->groupId ])) {
                            $this->sortedGroups[ ProductOptionGroupExcl::className(
                            ) ][ $option->groupId ] = $option->group;
                        }
                        $option->group->currentOptions[] = $option;
                    }
                    usort(
                        $this->sortedGroups[ ProductOptionGroupExcl::className() ],
                        function ($a, $b) {
                            /**
                             * @var OptionGroup $a
                             * @var OptionGroup $b
                             */
                            return $a->sort - $b->sort;
                        }
                    );
                }
                if (!empty($variantOptionCompls)) {
                    $this->sortedGroups[ ProductOptionGroupExcl::className() ] = [];
                    foreach ($variantOptionCompls as $option) {
                        if (empty($this->sortedGroups[ VariantOptionGroupCompl::className() ][ $option->groupId ])) {
                            $this->sortedGroups[ VariantOptionGroupCompl::className(
                            ) ][ $option->groupId ] = $option->group;
                        }
                        $option->group->currentOptions[] = $option;
                    }
                    usort(
                        $this->sortedGroups[ VariantOptionGroupCompl::className() ],
                        function ($a, $b) {
                            /**
                             * @var OptionGroup $a
                             * @var OptionGroup $b
                             */
                            return $a->sort - $b->sort;
                        }
                    );
                }
                if (!empty($variantOptionExcls)) {
                    $this->sortedGroups[ ProductOptionGroupExcl::className() ] = [];
                    foreach ($variantOptionExcls as $option) {
                        if (empty($this->sortedGroups[ VariantOptionGroupExcl::className() ][ $option->groupId ])) {
                            $this->sortedGroups[ VariantOptionGroupExcl::className(
                            ) ][ $option->groupId ] = $option->group;
                        }
                        $option->group->currentOptions[] = $option;
                    }
                    usort(
                        $this->sortedGroups[ VariantOptionGroupExcl::className() ],
                        function ($a, $b) {
                            /**
                             * @var OptionGroup $a
                             * @var OptionGroup $b
                             */
                            return $a->sort - $b->sort;
                        }
                    );
                }
            }
            return $this->sortedGroups;
        }
    
        public function canBuy()
        {
            return ( $this->stock && $this->price && $this->status );
        }
    
        /**
         * @return ActiveQuery
         */
        public static function findWithFilters()
        {
            return self::find()
                       ->with(
                           [
                               'product' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->with(
                                       [
                                           'productOptionCompls' => function ($query) {
                                               /**
                                                * @var ActiveQuery $query
                                                */
                                               $query->with('lang')
                                                     ->with('group.lang');
                                           },
                                       ]
                                   )
                                         ->with(
                                             [
                                                 'productOptionExcls' => function ($query) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->with('lang')
                                                           ->with('group.lang');
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'variantOptionCompls' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->with('lang')
                                         ->with('group.lang');
                               },
                           ]
                       )
                       ->with(
                           [
                               'variantOptionExcls' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->with('lang')
                                         ->with('group.lang');
                               },
                           ]
                       );
        }
    }