<?php
namespace app\components;

use app\components\helpers\SortingHelper;
use app\models\UserIdentity;
use yii\data\ActiveDataProvider;
use yii\db\ActiveQuery;
use yii\filters\auth\HttpBearerAuth;
use yii\helpers\ArrayHelper;
use yii\helpers\Json;
use yii\rest\ActiveController;
use app\components\behaviors\CorsBehavior;
use yii\web\BadRequestHttpException;
use yii\web\ForbiddenHttpException;

class BaseActiveController extends ActiveController
{
    public $serializer = [
        'class' => 'app\components\RestSerializer',
    ];

    const PAGESIZELIMIT_DEFAULT = 100;
    const PAGESIZELIMIT_MAX = 5000;

    protected static $actionPermissionMap = [
        'index' => 'read',
        'view' => 'read',
        'validate' => 'read',
        'options' => 'read',
        'create' => 'create',
        'update' => 'update',
        'patch' => 'update',
        'delete' => 'delete',
    ];
    protected static $permissionRequired = false;

    /**
     * @var string the scenario used to strict model validation
     */
    public $validateScenario = BaseModel::SCENARIO_STRICT_VALIDATE;

    public function behaviors()
    {
        $behaviors = parent::behaviors();

        if (\Yii::$app->params['cors-headers']) {
            $behaviors['cors-headers'] = [
                'class' => CorsBehavior::className(),
                'cors' => \Yii::$app->params['cors-headers'],
            ];
        }

        $behaviors['auth'] = [
            'class' => HttpBearerAuth::className(),
        ];

        return $behaviors;
    }

    /**
     * @inherit
     */
    public function actions()
    {
        $actions = parent::actions();

        $actions['index']['prepareDataProvider'] = [$this, 'prepareDataProvider'];

        $actions['validate'] = [
            'class' => 'app\components\actions\ValidateAction',
            'modelClass' => $this->modelClass,
            'checkAccess' => [$this, 'checkAccess'],
            'scenario' => $this->validateScenario,
        ];

        return $actions;
    }

    /**
     * @inheritdoc
     */
    public function checkAccess($action, $model = null, $params = [])
    {
        parent::checkAccess($action, $model, $params);
        $right = ArrayHelper::getValue(static::$actionPermissionMap, $action);

        if (!static::$permissionRequired || 'read' === $right) {
            return;
        }

        /** @var UserIdentity $identity */
        $identity = \Yii::$app->user->getIdentity();

        if (!$right || !$identity->can(static::$permissionRequired)->{$right}) {
            throw new ForbiddenHttpException();
        }
    }

    /**
     * @inheritdoc
     */
    public function prepareDataProvider()
    {
        /* @var $modelClass BaseModel */
        $modelClass = $this->modelClass;

        $subQuery = $modelClass::findWithJoin();

        $subQuery->addSelect($modelClass::tableName() . '.*');
        $subQuery->addSelect($modelClass::getAdditionalFields());
        $orderBy = SortingHelper::getOrderBy($modelClass, $subQuery);

        try {
            $filters = \Yii::$app->request->getQueryParam('filter', []);
            $filters = is_array($filters) ? $filters : (array)Json::decode($filters);
        } catch (\Throwable $e) {
            throw new BadRequestHttpException('JSON parse error: ' . $e->getMessage());
        }

        $query = new ActiveQuery($modelClass);
        $query->from([$subQuery]);
        $query->orderBy($orderBy);

        foreach ($filters as $key => $value) {
            if ($modelClass::isValidAttribute($key)) {
                $query->andFilterWhere($modelClass::getConditionClause($key, $value));
            }
        }

        $attributes = [
            'query' => $query,
            'pagination' => [
                'pageSizeLimit' => $this->getPageSizeLimit(),
            ],
        ];

        return new ActiveDataProvider($attributes);
    }

    protected function getPageSizeLimit()
    {
        $perPage = \Yii::$app->request->get('per-page');
        $allRecordsPageSize = '0';
        $allRecordsRequested = $allRecordsPageSize === $perPage;

        return $allRecordsRequested ? [self::PAGESIZELIMIT_MAX, self::PAGESIZELIMIT_MAX] : [1, self::PAGESIZELIMIT_DEFAULT];
    }
}