<?php
    
    namespace artbox\catalog\models;

    use artbox\catalog\behaviors\LevelBehavior;
    use artbox\catalog\models\queries\CategoryQuery;
    use artbox\core\behaviors\LanguageBehavior;
    use artbox\core\models\Image;
    use yii\behaviors\TimestampBehavior;
    use yii\db\ActiveRecord;
    use yii\db\ActiveQuery;
    use yii\web\Request;
    use artbox\core\models\Language;

    /**
     * This is the model class for table "category".
     *
     * @property integer                             $id
     * @property integer                             $image_id
     * @property integer                             $thumb_id
     * @property integer                             $parent_id
     * @property integer                             $level
     * @property integer                             $sort
     * @property boolean                             $status
     * @property integer                             $created_at
     * @property integer                             $updated_at
     * @property Image                               $image
     * @property Image                               $thumb
     * @property Category                            $parent
     * @property Category[]                          $categories
     * @property CategoryLang[]                      $categoryLangs
     * @property Language[]                          $languages
     * @property ProductToCategory[]                 $productToCategories
     * @property Product[]                           $products
     * @property ProductOptionGroupComplToCategory[] $productOptionGroupComplToCategories
     * @property ProductOptionGroupExclToCategory[]  $productOptionGroupExclToCategories
     * @property VariantOptionGroupComplToCategory[] $variantOptionGroupComplToCategories
     * @property VariantOptionGroupExclToCategory[]  $variantOptionGroupExclToCategories
     * @property ProductOptionGroupCompl[]           $productOptionGroupCompls
     * @property ProductOptionGroupExcl[]            $productOptionGroupExcls
     * @property VariantOptionGroupCompl[]           $variantOptionGroupCompls
     * @property VariantOptionGroupExcl[]            $variantOptionGroupExcls
     *      * From language behavior *
     * @property CategoryLang                        $lang
     * @property CategoryLang[]                      $langs
     * @property CategoryLang                        $objectLang
     * @property string                              $ownerKey
     * @property string                              $langKey
     * @property CategoryLang[]                      $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 CategoryLang[]   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 Category extends ActiveRecord
    {
    
        /**
         * @return CategoryQuery the active query used by this AR class.
         */
        public static function find()
        {
            return new CategoryQuery(get_called_class());
        }
        
        /**
         * @inheritdoc
         */
        public static function tableName()
        {
            return 'category';
        }
    
        /**
         * @inheritdoc
         */
        public function behaviors()
        {
            return [
                'language' => [
                    'class' => LanguageBehavior::className(),
                ],
                [
                    'class' => TimestampBehavior::className(),
                ],
                [
                    'class' => LevelBehavior::className(),
                ],
            ];
        }
    
        /**
         * @inheritdoc
         */
        public function rules()
        {
            return [
                [
                    [
                        'image_id',
                        'thumb_id',
                        'parent_id',
                        'level',
                        'sort',
                        'created_at',
                        'updated_at',
                    ],
                    'integer',
                ],
                [
                    [ 'status' ],
                    'boolean',
                ],
                [
                    [ 'parent_id' ],
                    'exist',
                    'skipOnError'     => true,
                    'targetClass'     => Category::className(),
                    'targetAttribute' => [ 'parent_id' => 'id' ],
                ],
            ];
        }
    
        /**
         * @inheritdoc
         */
        public function attributeLabels()
        {
            return [
                'id'         => \Yii::t('catalog', 'ID'),
                'image_id'   => \Yii::t('catalog', 'ID изображения'),
                'thumb_id'   => \Yii::t('catalog', 'ID миниатюры'),
                'parent_id'  => \Yii::t('catalog', 'Родительский ID'),
                'level'      => \Yii::t('catalog', 'Уровень'),
                'sort'       => \Yii::t('catalog', 'Сортировка'),
                'status'     => \Yii::t('catalog', 'Статус'),
                'created_at' => \Yii::t('catalog', 'Создано'),
                'updated_at' => \Yii::t('catalog', 'Обновлено'),
                'title'      => \Yii::t('catalog', 'Title'),
            ];
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getImage()
        {
            return $this->hasOne(Image::className(), [ 'id' => 'image_id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getThumb()
        {
            return $this->hasOne(Image::className(), [ 'id' => 'thumb_id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getParent()
        {
            return $this->hasOne(Category::className(), [ 'id' => 'parent_id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getCategories()
        {
            return $this->hasMany(Category::className(), [ 'parent_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getCategoryLangs()
        {
            return $this->hasMany(CategoryLang::className(), [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getLanguages()
        {
            return $this->hasMany(Language::className(), [ 'id' => 'language_id' ])
                        ->viaTable('category_lang', [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProductToCategories()
        {
            return $this->hasMany(ProductToCategory::className(), [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProducts()
        {
            return $this->hasMany(Product::className(), [ 'id' => 'product_id' ])
                        ->viaTable('product_to_category', [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProductOptionGroupComplToCategories()
        {
            return $this->hasMany(ProductOptionGroupComplToCategory::className(), [ 'category_id' => 'id' ])
                        ->inverseOf('category');
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProductOptionGroupCompls()
        {
            return $this->hasMany(ProductOptionGroupCompl::className(), [ 'id' => 'product_option_group_compl_id' ])
                        ->viaTable('product_option_group_compl_to_category', [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProductOptionGroupExclToCategories()
        {
            return $this->hasMany(ProductOptionGroupExclToCategory::className(), [ 'category_id' => 'id' ])
                        ->inverseOf('category');
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getProductOptionGroupExcls()
        {
            return $this->hasMany(ProductOptionGroupExcl::className(), [ 'id' => 'product_option_group_excl_id' ])
                        ->viaTable('product_option_group_excl_to_category', [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantOptionGroupComplToCategories()
        {
            return $this->hasMany(VariantOptionGroupComplToCategory::className(), [ 'category_id' => 'id' ])
                        ->inverseOf('category');
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantOptionGroupCompls()
        {
            return $this->hasMany(VariantOptionGroupCompl::className(), [ 'id' => 'variant_option_group_compl_id' ])
                        ->viaTable('variant_option_group_compl_to_category', [ 'category_id' => 'id' ]);
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantOptionGroupExclToCategories()
        {
            return $this->hasMany(VariantOptionGroupExclToCategory::className(), [ 'category_id' => 'id' ])
                        ->inverseOf('category');
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getVariantOptionGroupExcls()
        {
            return $this->hasMany(VariantOptionGroupExcl::className(), [ 'id' => 'variant_option_group_excl_id' ])
                        ->viaTable('variant_option_group_excl_to_category', [ 'category_id' => 'id' ]);
        }
    
        public static function findWithFilters(int $category_id): ActiveQuery
        {
            return self::find()
                       ->where([ 'category.id' => $category_id ])
                       ->with(
                           [
                               'productOptionGroupCompls' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'product_option_group_compl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                  => SORT_ASC,
                                           'product_option_group_compl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->orderBy(
                                                         [
                                                             'sort'                            => SORT_ASC,
                                                             'product_option_compl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'productOptionGroupExcls' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'product_option_group_excl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                 => SORT_ASC,
                                           'product_option_group_excl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->orderBy(
                                                         [
                                                             'sort'                           => SORT_ASC,
                                                             'product_option_excl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'variantOptionGroupCompls' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'variant_option_group_compl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                  => SORT_ASC,
                                           'variant_option_group_compl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->orderBy(
                                                         [
                                                             'sort'                            => SORT_ASC,
                                                             'variant_option_compl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'variantOptionGroupExcls' => function ($query) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'variant_option_group_excl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                 => SORT_ASC,
                                           'variant_option_group_excl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->orderBy(
                                                         [
                                                             'sort'                           => SORT_ASC,
                                                             'variant_option_excl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with('products.brand.lang.alias');
        }
        
        public static function findWithFiltersProducts(int $category_id): ActiveQuery
        {
            return self::find()
                       ->where([ 'category.id' => $category_id ])
                       ->with(
                           [
                               'productOptionGroupCompls' => function ($query) use($category_id) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'product_option_group_compl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                  => SORT_ASC,
                                           'product_option_group_compl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) use($category_id) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->select(['product_option_compl.*']);
                                                     $query->groupBy(['product_option_compl.id', 'product_option_compl_lang.value']);
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->innerJoinWith('products.productToCategories', false);
                                                     $query->andWhere(['product_to_category.category_id' => $category_id]);
                                                     $query->orderBy(
                                                         [
                                                             'sort'                            => SORT_ASC,
                                                             'product_option_compl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'productOptionGroupExcls' => function ($query) use($category_id) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->joinWith('productOptionGroupExclToCategories');
                                   $query->andWhere(
                                       [
                                           'product_option_group_excl_to_category.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                 => SORT_ASC,
                                           'product_option_group_excl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) use($category_id) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->select(['product_option_excl.*']);
                                                     $query->groupBy(['product_option_excl.id', 'product_option_excl_lang.value']);
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->innerJoinWith('products.productToCategories', false);
                                                     $query->andWhere(['product_to_category.category_id' => $category_id]);
                                                     $query->orderBy(
                                                         [
                                                             'sort'                           => SORT_ASC,
                                                             'product_option_excl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'variantOptionGroupCompls' => function ($query) use($category_id) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'variant_option_group_compl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                  => SORT_ASC,
                                           'variant_option_group_compl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) use($category_id) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->select(['variant_option_compl.*']);
                                                     $query->groupBy(['variant_option_compl.id', 'variant_option_compl_lang.value']);
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->innerJoinWith('variants.product.productToCategories', false);
                                                     $query->andWhere(['product_to_category.category_id' => $category_id]);
                                                     $query->orderBy(
                                                         [
                                                             'sort'                            => SORT_ASC,
                                                             'variant_option_compl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with(
                           [
                               'variantOptionGroupExcls' => function ($query) use($category_id) {
                                   /**
                                    * @var ActiveQuery $query
                                    */
                                   $query->andWhere(
                                       [
                                           'variant_option_group_excl.is_filter' => true,
                                       ]
                                   );
                                   $query->orderBy(
                                       [
                                           'sort'                                 => SORT_ASC,
                                           'variant_option_group_excl_lang.title' => SORT_ASC,
                                       ]
                                   );
                                   $query->innerJoinWith('lang.alias')
                                         ->with(
                                             [
                                                 'options' => function ($query) use($category_id) {
                                                     /**
                                                      * @var ActiveQuery $query
                                                      */
                                                     $query->select(['variant_option_excl.*']);
                                                     $query->groupBy(['variant_option_excl.id', 'variant_option_excl_lang.value']);
                                                     $query->innerJoinWith('lang.alias');
                                                     $query->innerJoinWith('variants.product.productToCategories', false);
                                                     $query->andWhere(['product_to_category.category_id' => $category_id]);
                                                     $query->orderBy(
                                                         [
                                                             'sort'                           => SORT_ASC,
                                                             'variant_option_excl_lang.value' => SORT_DESC,
                                                         ]
                                                     );
                                                 },
                                             ]
                                         );
                               },
                           ]
                       )
                       ->with('products.brand.lang.alias');
        }
    }