<?php
    namespace frontend\controllers;

    use common\models\Blog;
    use common\models\Fields;
    use common\models\Gallery;
    use common\models\Portfolio;
    use common\models\PortfolioSpecialization;
    use common\models\Team;
    use common\models\Vacancy;
    use common\models\VacancySpecialization;
    use Yii;
    use yii\data\ActiveDataProvider;
    use yii\data\ArrayDataProvider;
    use yii\data\Pagination;
    use yii\data\Sort;
    use yii\helpers\ArrayHelper;
    use yii\web\BadRequestHttpException;
    use yii\web\Controller;
    use common\models\User;
    use yii\web\NotFoundHttpException;

    /**
     * Site controller
     */
    class CompanyController extends Controller
    {

        public $layout = 'company';

        public $defaultAction = 'common';

        /**
         * @inheritdoc
         */
        public function actions()
        {
            return [
                'error'   => [
                    'class' => 'yii\web\ErrorAction',
                ],
                'captcha' => [
                    'class'           => 'yii\captcha\CaptchaAction',
                    'fixedVerifyCode' => YII_ENV_TEST ? 'testme' : NULL,
                ],
            ];
        }

        public function actionCommon($company_id, $type = 'implementer')
        {
            /**
             * @var User $company
             */
            if(!$company = User::find()
                               ->where([ 'id' => $company_id ])
                               ->with('teams')
                               ->with('teams.department')
                               ->with('userInfo')
                               ->with('companyInfo')
                               ->one()
            ) {
                throw new NotFoundHttpException('Компания не найдена');
            }

            $projectProvider = new ActiveDataProvider([
                'query' => $company->getProjects(),
            ]);

            $blogProvider = new ActiveDataProvider([
                'query'      => $company->getBlog()
                                        ->with('comments'),
                'sort'       => new Sort([
                    'defaultOrder' => [
                        'date_add' => SORT_DESC,
                        'name'     => SORT_ASC,
                    ],
                ]),
                'pagination' => new Pagination([
                    'pageSize'  => 2,
                    'pageParam' => '',
                ]),
            ]);

            $commentProvider = new ActiveDataProvider([
                'query'      => $company->getComments()
                                        ->with('rating')
                                        ->with('author'),
                'sort'       => new Sort([
                    'defaultOrder' => [
                        'date_add' => SORT_DESC,
                    ],
                ]),
                'pagination' => new Pagination([
                    'pageSize'  => 4,
                    'pageParam' => '',
                ]),
            ]);

            return $this->render('common', [
                'company'         => $company,
                'projectProvider' => $projectProvider,
                'blogProvider'    => $blogProvider,
                'commentProvider' => $commentProvider,
            ]);
        }

        public function actionProjects($company_id, $type = 'implementer')
        {
            $company = User::findOne($company_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $dataProvider = new ActiveDataProvider([
                'query'      => $company->getProjects(),
                'pagination' => [
                    'pageSize' => 10,
                ],
            ]);

            return $this->render('project-list', [
                'company'         => $company,
                'dataProvider' => $dataProvider,
            ]);
        }

        public function actionPortfolio($company_id, $type = 'implementer')
        {
            $company = User::findOne($company_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }
            $projects = ArrayHelper::getColumn($company->portfolios, 'portfolio_id');

            $filters = PortfolioSpecialization::find()
                                              ->select([
                                                  "specialization_id",
                                                  "COUNT('specialization_id') AS count",
                                              ])
                                              ->where([ "portfolio_id" => $projects ])
                                              ->groupBy("specialization_id")
                                              ->all();

            $portfolio = new ArrayDataProvider([
                'allModels'  => $company->getPortfolios()
                                        ->orderBy('portfolio_id')
                                        ->all(),
                'pagination' => [
                    'pageSize' => 9,
                ],
            ]);

            return $this->render('portfolio', [
                'company'   => $company,
                'filters'   => $filters,
                'portfolio' => $portfolio,
                'count'     => count($company->portfolios),
            ]);
        }

        public function actionPortfolioFilter($performer_id, $filter, $type = 'implementer')
        {
            $company = User::findOne($performer_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }
            $portfolios = ArrayHelper::getColumn($company->portfolios, 'portfolio_id');

            $filters = PortfolioSpecialization::find()
                                              ->select([
                                                  "specialization_id",
                                                  "COUNT('specialization_id') AS count",
                                              ])
                                              ->where([ "portfolio_id" => $portfolios ])
                                              ->groupBy("specialization_id")
                                              ->all();

            $filter_result = PortfolioSpecialization::find()
                                                    ->where([
                                                        'specialization_id' => $filter,
                                                        'portfolio_id'      => $portfolios,
                                                    ])
                                                    ->all();

            $portfolio = new ArrayDataProvider([
                'allModels'  => Portfolio::find()
                                         ->where([ 'portfolio_id' => ArrayHelper::getColumn($filter_result, 'portfolio_id') ])
                                         ->all(),
                'pagination' => [
                    'pageSize' => 9,
                ],
            ]);

            return $this->render('portfolio', [
                'company'   => $company,
                'filters'   => $filters,
                'portfolio' => $portfolio,
                'filter_id' => $filter,
                'count'     => count($company->portfolios),
            ]);
        }

        public function actionPortfolioView($company_id, $portfolio_id, $type = 'implementer')
        {
            $user = User::findOne($company_id);
            $portfolio = $user->getPortfolios()
                              ->where([ 'portfolio_id' => $portfolio_id ])
                              ->one();
            $portfolio->updateCounters([ 'view_count' => 1 ]);
            return $this->render('portfolio-view', [
                'user'      => $user,
                'portfolio' => $portfolio,
            ]);
        }

        public function actionTeam($company_id, $type = 'implementer')
        {
            $company = User::findOne($company_id);
            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }
            $comments = new ActiveDataProvider([
                'query'      => $company->getComments(),
                'pagination' => [
                    'pageSize' => 4,
                ],
            ]);
            $query = Team::find()
                         ->where([ 'user_id' => $company_id ]);
            $team = new ActiveDataProvider([
                'query'      => $query,
                'pagination' => [
                    'pageSize' => 9,
                ],
            ]);
            return $this->render('team', [
                'company'  => $company,
                'team'     => $team,
                'comments' => $comments,
            ]);
        }

        public function actionBlogList($company_id, $type = 'implementer')
        {
            $company = User::findOne($company_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $blog = new ActiveDataProvider([
                'query' => $company->getBlog(),
                'pagination' => new Pagination([
                    'pageSize' => 5,
                ]),
                'sort' => new Sort([
                    'defaultOrder' => [
                        'date_add' => SORT_DESC,
                        'name' => SORT_ASC,
                    ],
                ]),
            ]);

            return $this->render('blog-list', [
                'company'    => $company,
                'blog'       => $blog,
            ]);
        }

        public function actionBlogView($company_id, $link, $type = 'implementer')
        {
            $company = User::findOne($company_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $article = Blog::find()
                           ->where([
                               'link'    => $link,
                               'user_id' => $company_id,
                           ])
                           ->with('comments')
                           ->one();
            $article->updateCounters([ 'view_count' => 1 ]);

            return $this->render('blog-view', [
                'company' => $company,
                'article' => $article,

            ]);
        }

        public function actionReview($company_id, $type = 'implementer')
        {
            $company = User::findOne($company_id);

            return $this->render('review', [
                'company' => $company,
            ]);
        }

        public function actionVacancyList($company_id, $type = 'implementer')
        {

            $company = User::findOne($company_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $query = $company->getVacancies();

            $provider = new ActiveDataProvider([
                'query'      => $query,
                'pagination' => [
                    'pageSize' => 5,
                ],
                'sort'       => [
                    'defaultOrder' => [
                        'date_add' => SORT_DESC,
                        'name'     => SORT_ASC,
                    ],
                ],
            ]);

            return $this->render('vacancy-list', [
                'company'  => $company,
                'provider' => $provider,
            ]);

        }

        public function actionVacancyView($company_id, $link, $type = 'implementer')
        {
            $company = User::findOne($company_id);
            $vacancy = $company->getVacancies()
                               ->where([ 'link' => $link ])
                               ->with([
                                   'employments',
                                   'specializations',
                               ])
                               ->one();

            $specialization_id = $vacancy->getSpecializations()
                                         ->select('specialization_id')
                                         ->column();

            $vacancy_id = VacancySpecialization::find()
                                               ->where([ 'specialization_id' => $specialization_id ])
                                               ->select('vacancy_id')
                                               ->column();

            $similar_vacancies = Vacancy::find()
                                        ->where([
                                            'city'       => $vacancy->city,
                                            'vacancy_id' => $vacancy_id,
                                        ])
                                        ->andFilterWhere([
                                            '<>',
                                            'vacancy_id',
                                            $vacancy->vacancy_id,
                                        ])
                                        ->orderBy([ 'vacancy_id' => SORT_DESC ])
                                        ->limit(3)
                                        ->all();

            return $this->render('vacancy-view', [
                'company'           => $company,
                'vacancy'           => $vacancy,
                'similar_vacancies' => $similar_vacancies,
            ]);
        }

        public function actionGallery($company_id, $type = 'implementer')
        {
            $company = User::findOne($company_id);

            if(!$company instanceof User) {
                throw new BadRequestHttpException('Пользователь не найден');
            }

            $query = Gallery::find()
                            ->where([ 'user_id' => $company_id ]);

            $countQuery = clone $query;

            $pagination = new Pagination([
                'totalCount' => $countQuery->count(),
                'pageSize'   => 5,
            ]);

            $gallery = $query->offset($pagination->offset)
                             ->limit($pagination->limit)
                             ->all();

            $gallery = new ArrayDataProvider([
                'allModels' => $gallery,
            ]);

            $videos = Fields::getData($company->id, Gallery::className(), 'youtube');

            $this->layout = 'gallery-company';

            return $this->render('gallery', [
                'company'    => $company,
                'gallery'    => $gallery,
                'pagination' => $pagination,
                'videos'     => $videos,
            ]);
        }

        public function beforeAction($action)
        {
            if(!empty(\Yii::$app->request->get('type'))) {
                $action->controller->view->params['type'] = \Yii::$app->request->get('type');
            }
            if(!empty(\Yii::$app->request->get('company_id'))) {
                $user = User::findOne(\Yii::$app->request->get('company_id'));
                if(!empty($user) && $user->type == 1) {
                    $queryParams = \Yii::$app->request->queryParams;
                    unset($queryParams['company_id']);
                    $queryParams['performer_id'] = $user->id;
                    return $this->redirect(array_merge(['performer/'.$action->id], $queryParams));
                }
            }
            return parent::beforeAction($action);
        }
    }