<?php

namespace admin\models\search;

use Yii;
use yii\base\DynamicModel;
use yii\base\Model;
use yii\data\ActiveDataProvider;
use admin\models\Page;
use yii\db\ActiveQuery;
use yii\db\ActiveRecord;

/**
 * PageSearch represents the model behind the search form of `backend\models\Page`.
 */
class CommonSearch extends DynamicModel
{
    /** @var \Closure */
    /** @var \Closure[] */
    public $filters;

    public $additionRules = [];

    public $defaultSort = [];
    public $query;
    /**
     * @param ActiveRecord $model
     */
    public function __construct($attributes)
    {
        $attributes[] = 'page';
        $attributes[] = 'limit';
        parent::__construct($attributes);
    }

    public function setDefaultSort($sort){
        $this->defaultSort = $sort;
    }

    public function injectFilters($filters){
        foreach ($filters as $filter){
            if(!isset($filter['rules'])){
                $this->addRule($filter['field'],'string');
            }else{
                foreach ($filter['rules'] as $rule){
                    $this->addRule(...$rule);
                }
            }
            $searchField = $filter['field'];
            if(isset($filter['searchFields'])){
                $searchField = $filter['searchFields'];
            }
            $searchFields = explode(',',$searchField);
            if(isset($filter['searchType'])) {
                switch ($filter['searchType']) {
                    case 'like':
                        if (count($searchFields) > 1) {
                            $condition[] = 'or';
                            foreach ($searchFields as $sf) {
                                $condition[] = ['like', 'name', $this->$sf];
                            }
                        } else {
                            $condition = ['like', 'name', $this->{$searchFields[0]}];
                        }
                        $this->bindFilter(function ($q) use ($condition) {
                            return $q->andFilterWhere($condition);
                        });
                        break;
                    case 'equal':
                        if (count($searchFields) > 1) {
                            $condition[] = 'or';
                            foreach ($searchFields as $sf) {
                                $condition[] = ['like', 'name', $this->$sf];
                            }
                        } else {
                            $condition = ['like', 'name', $this->{$searchFields[0]}];
                        }
                        $this->bindFilter(function ($q) use ($condition) {
                            return $q->andFilterWhere($condition);
                        });
                        break;
                    default:
                        //$condition[] = 'or';
                        //foreach ($searchFields as $sf) {
                        //    $condition[] = [$sf => $this->$sf];
                        //}
                        //$this->bindFilter(function ($q) use ($condition) {
                        //    return $q->andFilterWhere($condition);
                        //});
                        break;
                        break;

                    //case 'select':
                    //    $filter1->select($filter['data']);
                    //    break;
                    //case 'cascader':
                    //    $filter1->cascader($filter['data']);
                    //    break;
                    //case 'date':
                    //    $filter1->date($filter['placeholder']);
                    //    break;
                    //case 'datetime':
                    //    $filter1->datetime($filter['placeholder']);
                    //    break;
                    //case 'daterange':
                    //    $filter1->daterange($filter['placeholder']);
                    //    break;
                }
            }
        }
    }

    public function setQuery($query){
        $this->query = $query;
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return array_merge([
            ['page','integer','min'=>1,'max'=>99999],
            ['limit','integer','min'=>1,'max'=>500],
        ],$this->additionRules);
    }

    /**
     * @inheritdoc
     */
    public function scenarios()
    {
        // bypass scenarios() implementation in the parent class
        return Model::scenarios();
    }
    /**
     * Creates data provider instance with search query applied
     *
     * @param array $params
     *
     * @return ActiveDataProvider|array
     */
    public function search($params)
    {

        $dataProvider = new ActiveDataProvider([
            'query' => $this->query,
            'sort'=>[
                'defaultOrder'=>$this->defaultSort
            ]
        ]);
        $this->load($params,'');
        if (!$this->validate()) {
            // uncomment the following line if you do not want to return any records when validation fails
            // $query->where('0=1');
            return ['error'=>$this->getErrors()];
        }        // add conditions that should always apply here
        $pagination = [];
        $defaultPageSize = 20;
        if (isset($this->page)) {
            $pagination['page'] = $this->page;
        }
        if (isset($this->limit)) {
            $defaultPageSize = $this->limit;
        }
        $pagination = [
            'defaultPageSize' => $defaultPageSize,
            'params' => $pagination
        ];
        $dataProvider->setPagination($pagination);
        // grid filtering conditions

        if(!empty($this->filters)){
            foreach($this->filters as $filter){
                $filter->call($this,$this->query);
            }
        }
        return $dataProvider;
    }

    public function bindFilter(\Closure $func){
        $this->filters[] = $func->bindTo($this,static::class);
    }
}