<?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\PortfolioUser;
    use common\models\Specialization;
    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\db\ActiveQuery;
    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';

        public function afterAction($action, $result)
        {
            $result = parent::afterAction($action, $result);
            if(!empty( $action->controller->actionParams[ 'company_id' ] )) {
                $company_id = $action->controller->actionParams[ 'company_id' ];
                $user = User::findOne($company_id);
                if(!empty( $user->userInfo )) {
                    if($user->userInfo->is_freelancer xor $user->userInfo->is_customer) {
                        $type = $action->controller->actionParams['type'];
                        $get = \Yii::$app->request->get();
                        if(!empty($type)) {
                            if($user->userInfo->is_freelancer && $type == 'customer') {
                                $get['type'] = 'implementer';
                                $this->redirect(array_merge([$action->id], $get));
                            } elseif($user->userInfo->is_customer && $type == 'implementer') {
                                $get['type'] = 'customer';
                                $this->redirect(array_merge([$action->id], $get));
                            }
                        }
                    }
                    if($user->id != \Yii::$app->user->id) {
                        $user->userInfo->updateCounters([ 'view_count' => 1 ]);
                    }
                }
            }
            return $result;
        }

        /**
         * @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->getPortfolios(),
            ]);

            $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('user'),
                '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::find()
                           ->where([
                               'id' => $company_id,
                           ])
                           ->joinWith([
                               'portfolios' => function($query) {
                                   $query->indexBy('portfolio_id');
                               },
                               'portfolios.specializations',
                           ])
                           ->one();

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

            $filters = Specialization::find()
                                     ->select([
                                         'count' => 'COUNT(portfolio_specialization.specialization_id)',
                                         'portfolio_specialization.specialization_id',
                                         'specialization.specialization_name',
                                     ])
                                     ->join('INNER JOIN', 'portfolio_specialization', 'specialization.specialization_id = portfolio_specialization.specialization_id')
                                     ->where([ 'portfolio_specialization.portfolio_id' => array_keys($company->portfolios) ])
                                     ->groupBy([
                                         'portfolio_specialization.specialization_id',
                                         'specialization.specialization_name',
                                     ])
                                     ->indexBy('specialization_id')
                                     ->asArray()
                                     ->all();

            $portfolio = new ActiveDataProvider([
                'query'      => $company->getPortfolios(),
                'pagination' => [
                    'pageSize' => 9,
                ],
                'sort'       => new Sort([
                    'defaultOrder' => [
                        'portfolio_id' => SORT_DESC,
                    ],
                ]),
            ]);

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

        public function actionPortfolioFilter($company_id, $filter, $type = 'implementer')
        {
            $company = User::find()
                           ->where([
                               'id' => $company_id,
                           ])
                           ->joinWith([
                               'portfolios' => function($query) {
                                   $query->indexBy('portfolio_id');
                               },
                               'portfolios.specializations',
                           ])
                           ->one();

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

            $filters = Specialization::find()
                                     ->select([
                                         'count' => 'COUNT(portfolio_specialization.specialization_id)',
                                         'portfolio_specialization.specialization_id',
                                         'specialization.specialization_name',
                                     ])
                                     ->join('INNER JOIN', 'portfolio_specialization', 'specialization.specialization_id = portfolio_specialization.specialization_id')
                                     ->where([ 'portfolio_specialization.portfolio_id' => array_keys($company->portfolios) ])
                                     ->groupBy([
                                         'portfolio_specialization.specialization_id',
                                         'specialization.specialization_name',
                                     ])
                                     ->indexBy('specialization_id')
                                     ->asArray()
                                     ->all();

            $portfolio = new ActiveDataProvider([
                'query'      => $company->getPortfolios()
                                        ->joinWith('specializations')
                                        ->where([ 'portfolio_specialization.specialization_id' => $filter ]),
                'pagination' => [
                    'pageSize' => 9,
                ],
            ]);

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

        public function actionPortfolioView($company_id, $portfolio_id, $portfolio_user = NULL, $type = 'implementer')
        {
            $user = User::findOne($company_id);
            $portfolio = $user->getPortfolios()
                              ->where([ 'portfolio_id' => $portfolio_id ])
                              ->with([
                                  'portfolioUsers' => function($query) {
                                      /**
                                       * @var ActiveQuery $query
                                       */
                                      $query->andWhere([ 'status' => 1 ]);
                                  },
                              ])
                              ->with('portfolioUsers.gallery')
                              ->one();
            if(empty($portfolio)) {
                throw new NotFoundHttpException('Портфолио не найдено');
            }
            if(!empty( $portfolio_user )) {
                $portfolio_user = PortfolioUser::find()
                                               ->where([
                                                   'portfolio_user_id' => $portfolio_user,
                                                   'status'            => 1,
                                               ])
                                               ->with('gallery')
                                               ->with('user')
                                               ->one();
                if(empty( $portfolio_user )) {
                    $this->redirect([
                        'portfolio-view',
                        'performer_id' => $company_id,
                        'portfolio_id' => $portfolio_id,
                        'type'         => $type,
                    ]);
                }
            } else {
                $portfolio->updateCounters([ 'view_count' => 1 ]);
            }
            return $this->render('portfolio-view', [
                'user'           => $user,
                'portfolio'      => $portfolio,
                'portfolio_user' => $portfolio_user,
            ]);
        }

        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();
            if(empty($article)) {
                throw new NotFoundHttpException('Запись не найдена');
            }
            $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);

            if(empty($company)) {
                throw new NotFoundHttpException('Company not found');
            }

            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('Пользователь не найден');
            }

            $gallery = new ActiveDataProvider([
                'query'      => $company->getGalleries(),
                'pagination' => [
                    'pageSize' => 5,
                ],
            ]);

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

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

            return $this->render('gallery', [
                'company' => $company,
                'gallery' => $gallery,
                '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);
        }
    }