<?php
    
    namespace artbox\catalog\catalog\models;

    use artbox\catalog\behaviors\LevelBehavior;
    use artbox\catalog\filter\models\Group;
    use artbox\catalog\models\ProductOptionGroupCompl;
    use artbox\catalog\models\ProductOptionGroupComplToCategory;
    use artbox\catalog\models\ProductOptionGroupExclToCategory;
    use artbox\catalog\models\queries\CategoryQuery;
    use artbox\catalog\models\VariantOptionGroupCompl;
    use artbox\catalog\models\VariantOptionGroupComplToCategory;
    use artbox\catalog\models\VariantOptionGroupExcl;
    use artbox\catalog\models\VariantOptionGroupExclToCategory;
    use artbox\core\models\Image;
    use artbox\core\models\traits\AliasableTrait;
    use common\models\blog\Article;
    use yii\behaviors\TimestampBehavior;
    use yii\db\ActiveRecord;
    use yii\db\ActiveQuery;
    use yii\helpers\Json;
    use artbox\core\models\Language;
    use yii2tech\ar\linkmany\LinkManyBehavior;
    use yii2tech\ar\position\PositionBehavior;
    use yii2tech\ar\variation\VariationBehavior;

    /**
     * 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
     * from VariationBehavior
     * @method ActiveQuery  hasDefaultVariationRelation();
     */
    class Category extends ActiveRecord
    {
        use AliasableTrait;
        
        /**
         * @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 [
                'translations' => [
                    'class'                             => VariationBehavior::className(),
                    'variationsRelation'                => 'languages',
                    'defaultVariationRelation'          => 'language',
                    'variationOptionReferenceAttribute' => 'language_id',
                    'optionModelClass'                  => Language::className(),
                    'defaultVariationOptionReference'   => function () {
                        return Language::getCurrent()->id;
                    },
                    'optionQueryFilter'                 => function (ActiveQuery $query) {
                        $query->where(
                            [
                                'status' => true,
                            ]
                        );
                    },
                ],
                'timestamp' => [
                    'class' => TimestampBehavior::className(),
                ],
                'level' => [
                    'class' => LevelBehavior::className(),
                ],
                'positionBehavior'     => [
                    'class'             => PositionBehavior::className(),
                    'positionAttribute' => 'sort',
                ],
                'linkGroupBehavior' => [
                    'class'                      => LinkManyBehavior::className(),
                    'relation'                   => 'groups',
                    'relationReferenceAttribute' => 'groupIds',
                ],
                'linkArticleBehavior' => [
                    'class'                      => LinkManyBehavior::className(),
                    'relation'                   => 'articles',
                    'relationReferenceAttribute' => 'articleIds',
                ],
            ];
        }
    
        /**
         * @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' ],
                ],
                [
                    [
                    'groupIds',
                    'articleIds',
                    ],
                    'safe',
                ],
            ];
        }
    
        /**
         * @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'),
                'articleIds' => \Yii::t('catalog', 'Articles'),
                'groupIds'   => \Yii::t('catalog', 'Option Groups'),
            ];
        }
    
        /**
         * @return string
         */
        public function getRoute()
        {
            return Json::encode(
                [
                    'category/view',
                    'id' => $this->id,
                ]
            );
        }
    
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getLanguage()
        {
            return $this->hasDefaultVariationRelation();
        }
        /**
         * @return \yii\db\ActiveQuery
         */
        public function getLanguages()
        {
            return $this->hasMany(CategoryLang::className(), [ 'category_id' => 'id' ]);
        }
    
        /**
         * @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' ]);
        }
    
        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->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');
        }
    
        /**
         * @param int $category_id
         *
         * @return \yii\db\ActiveQuery
         */
        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' => function (ActiveQuery $query) use (
                                               $category_id
                                           ) {
                                               $query->where(
                                                   [
                                                       'product_option_group_excl_to_category.category_id' => $category_id,
                                                   ]
                                               );
                                           },
                                       ]
                                   );
                                   $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');
        }
    
        /**
         * @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 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' ]);
        }
    
        /**
         * @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 getArticles()
        {
            return $this->hasMany(Article::className(), [ 'id' => 'article_id' ])
                        ->viaTable('article_to_category', [ 'category_id' => 'id' ]);
        }
    
        public function getGroups()
        {
            return $this->hasMany(Group::className(), [ 'id' => 'product_option_group_excl_id' ])
                        ->viaTable('product_option_group_excl_to_category', [ 'category_id' => 'id' ]);
        }
    }