<?php
/**
 * Разработал Максим Руденко
 * email: rudenko.programmer@gmail.com
 * Дата: 13.12.2017
 */

namespace frontend\controllers;

use common\models\bbapi\UtcObject;
use common\models\bbapi\UtcReportObject;
use common\models\external_user\ExternalUser;
use common\models\MailSender;
use common\models\opportunities\OpportunitiesLogs;
use common\models\opportunities\OpportunitiesModel;
use common\models\rocket_chat\RocketChatCT;
use common\models\Slack;
use common\models\team\Team;
use common\models\team\TeamUser;
use common\models\tnd\MatchingCandidate;
use common\models\tnd\MatchingOpportunity;
use common\models\User;

use common\models\UserApiData;
use common\models\UserManagementData;
use common\models\UserManagementDataRules;
use common\models\UserNotifications;
use common\models\UserProfile;
use Yii;
use yii\helpers\ArrayHelper;
use yii\helpers\Url;
use yii\web\Controller;

use yii\filters\AccessControl;

/**
 * Class view opportunities and respond for create, update actions
 * Class OpportunitiesController
 * @package frontend\controllers
 */
class OpportunitiesController  extends Controller
{
	public $layout = 'ct-main-layout';

	public function behaviors()
	{

		return [
			'access' => [
				'class' => AccessControl::className(),
				'only' => ['insert', 'insert-b', 'view', 'management', 'matching-view'],
				'rules' => [
					/*[
						'allow' => true,
						'actions' => ['login', 'signup'],
						'roles' => ['?'],
					],*/
					[
						'allow' => true,
						'actions' => ['insert', 'insert-b', 'view', 'management', 'matching-view'],
						'roles' => [User::ROLE_USER3],
					],
				],
			],
		];
	}

	/**
	 * View insert opportunity page step A
	 * @param int $id
	 *
	 * @return string|\yii\web\Response
	 */
	public function actionInsert($id=0){
		if($id != 0){
			$opportunities = OpportunitiesModel::find()->where(['id' => $id])->andWhere(['owner_id' => Yii::$app->user->id])->one();
			if(!$opportunities){
				return $this->redirect(['profile/index']);
			}

			if($opportunities && ($opportunities->status == OpportunitiesModel::ACCEPTED
				|| $opportunities->status == OpportunitiesModel::UNACCEPTED)){
				return $this->redirect(['opportunities/insert-b?id='.$id]);
			}

			if($opportunities && $opportunities->status === OpportunitiesModel::REJECTED){
				$errors = OpportunitiesLogs::find()->where(['opportunity_id' => $opportunities->id])->andWhere(['status'=>OpportunitiesLogs::EVENT_OPPORTUNITY_REJECT])
					->orderBy(['created_at'=>SORT_DESC])->all();
				return $this->render('insert-a', compact('errors'));
			}
		}
		return $this->render('insert-a');
	}

	/**
	 * View insert opportunity page step B
	 * @param $id
	 *
	 * @return string|\yii\web\Response
	 */
	public function actionInsertB($id){
		$opportunities = OpportunitiesModel::find()->where(['id' => $id])->andWhere(['owner_id' => Yii::$app->user->id])->one();


		if(!$opportunities){
			return $this->redirect(['profile/index']);
		}

		if($opportunities && $opportunities->status == OpportunitiesModel::REJECTED){
			return $this->redirect(['opportunities/insert?id='.$id]);
		}

		if($opportunities) {
			$user_id = Yii::$app->user->id;
			/** @var \common\models\User $user */
			$user = User::find()->where(['id' =>$user_id])->one();
			$tnd_token = ApiController::getTNDToken(2, 'EN', $user->internal_user_id, $user->getExternalId(), $opportunities->id);

			return $this->render( 'insert-b', compact('opportunities', 'tnd_token') );
		}
		return $this->redirect(['profile/index']);
	}

	/**
	 * Google places event
	 * @return bool|\Error|\Exception|string
	 */
	public function actionGooglePlace(){
		if(Yii::$app->request->isPost && Yii::$app->request->post('input', false)){
			$url = 'https://maps.googleapis.com/maps/api/place/queryautocomplete/json';
			$key = 'AIzaSyBgx7y0_wFrWezm3mTVaU-vcQCMaBzOvwU';
			$input = Yii::$app->request->post('input');
			try{
				return file_get_contents("$url?key=$key&input=$input");
			}catch (\Error $e){
				return $e;
			}
		}
	}

	/**
	 * @param $id
	 *
	 * @return string
	 */
	public function actionManagement($id){
		$current_opportunities = OpportunitiesModel::findOne($id);
//		$current_team_member = $current_opportunities->team->teamUser;
		$user = User::findOne(Yii::$app->user->id);
		if($current_opportunities->isOwner($user->id)){
			$current_team_member = $current_opportunities->team->teamUser;
		}
		else{
			$current_team_member = $current_opportunities->team->getTeamListForUser($user->id);
		}
		return $this->render('opport-managment', compact('user','current_opportunities', 'current_team_member'));
	}

	/**
	 * Get user data by email for invite
	 * @return string
	 */
	public function actionApiGetUserByEmail(){
		if(Yii::$app->request->isPost && Yii::$app->request->post('email', false)){
			try{
				/* TODO уточнить по каким полям сортировать */
				$user = User::findOne(['email' => Yii::$app->request->post('email')]);

				if($user){
					/** @var \common\models\UserManagementData $management_data */
					$management_data = UserManagementData::findOne(['user_id' => $user->id]);

					return json_encode([
						'status' => 'OK',
						'context' => [
							'user_id' => $user->id,
							'user_name' => $user->username,
							'user_surname' => $user->surname,
							'user_email' => $user->email,
							'user_img' => $user->myprofile->image,
							'management_data' => [
								'is_full_utc' => $management_data->is_full_utc,
							],
						],
					]);
				}
				else{
					return json_encode([
						'status' => 'Error',
						'context' => 'User does not exist',
					]);
				}
			}catch (\Error $e){
				return json_encode([
					'status' => 'ERROR',
					'context' => $e,
				]);
			}
		}
	}

	/**
	 * TODO переделать под а б ц
	 * @return string
	 */
	public function actionApiCreate(){
		if(Yii::$app->request->isPost && Yii::$app->request->post('data', false)){
			$data = json_decode(Yii::$app->request->post('data'));

			/** Change opportunity if create */
			if((int)$data->team_id > 0){
				$opportunity = OpportunitiesModel::findOne((int)$data->team_id);
				$opportunity->title = $data->title;
				$opportunity->description = $data->description;
				$start_date = $data->start_date_year.'-'.$data->start_date_month.'-1';
				$opportunity->start_date = strtotime($start_date);
				$opportunity->incorporation = $data->incorporation;
				$opportunity->main_markets = implode(',', $data->main_markets);
				$opportunity->site_url = $data->site_url;
				$opportunity->social_in_url = $data->social_in;
				$opportunity->social_fb_url = $data->social_fb;
				$opportunity->social_gp_url = $data->social_gp;
				$opportunity->basecamp = $data->basecamp;
				$opportunity->status = OpportunitiesModel::UNACCEPTED;

				if($opportunity->validate() && $opportunity->save()){
					/**
					 * TODO @event_log insert new opportunity log
					 */
					OpportunitiesLogs::createOpportunityEvents($opportunity->id, OpportunitiesLogs::EVENT_OPPORTUNITY_RECHECK);

					/** TODO create notification and send message to admin  */
//					UserNotifications::setNotification($opportunity->owner_id, UserNotifications::TYPE_OPPORT_CHANGE,
//						"You opportunity {$opportunity->title} has changed", '', Url::to(['opportunities/insert-b?id='.$opportunity->id]));

//					UserNotifications::sendMailToPost($opportunity->owner_id, UserNotifications::TYPE_OPPORT_CHANGE, $opportunity->id);

					/** @var  User $owner */
					$owner = $opportunity->owner;
					/**
					 * TODO @event_mail Insert Opportunity event name - send message via mandrill
					 */
					/*$adminEmailUrl = Yii::$app->params['adminEmail'].'/opportunities/check-opportunities?id='.$opportunity->id;
					$sendEmailResult = Yii::$app->mailer
					->compose('opportunitie-create',[
						'USERNAME' => $owner->username,
						'OPPORTNAME' => $opportunity->title,
						'URL' => $adminEmailUrl,
					])
					->setFrom([Yii::$app->params['adminEmail']=>Yii::$app->params['adminEmail']])
					->setTo(Yii::$app->params['adminEmail'])
					->send();*/
					$sendEmailResult = MailSender::sendToAdmin_CreateNewOpp($opportunity);

					return json_encode([
						'status' => 'OK',
						'context' => [
							'id' => $opportunity->id,
							'data' => json_decode(Yii::$app->request->post('data')),
						],
					]);
				}
			}

			/** Create new opportunity */
			$opportunity = new OpportunitiesModel();
			$opportunity->title = $data->title;
			$opportunity->description = $data->description;
			$start_date = $data->start_date_year.'-'.$data->start_date_month.'-1';
			$opportunity->start_date = strtotime($start_date);
			$opportunity->incorporation = $data->incorporation;
			$opportunity->main_markets = implode(',', $data->main_markets);
			$opportunity->site_url = $data->site_url;
			$opportunity->social_in_url = $data->social_in;
			$opportunity->social_fb_url = $data->social_fb;
			$opportunity->social_gp_url = $data->social_gp;
			$opportunity->basecamp = $data->basecamp;
			$opportunity->owner_id = $data->owner_id;
			$opportunity->lifecycle_stage = '';
			$opportunity->lifetime_rev_currency = '';
			$opportunity->lifetime_rev_value = '';
			$opportunity->last_rev_currency = '';
			$opportunity->last_rev_value = '';
			$opportunity->opportunity_purpose = '';
			$opportunity->vision = '';
			$opportunity->proposition = '';
			$opportunity->key_customer = '';
			$opportunity->target_markets = '';
			$opportunity->interaction = '';
			$opportunity->funding = '';
			$opportunity->status = OpportunitiesModel::UNACCEPTED;

			$user = User::findOne($data->owner_id);
			$user->managementData->is_opportunity = 1;
			$user->managementData->save();

			if($opportunity->validate() && $opportunity->save()){
				/**
				 * TODO @event_log insert new opportunity log
				 */
				OpportunitiesLogs::createOpportunityEvents($opportunity->id, OpportunitiesLogs::EVENT_OPPORTUNITY_CREATE);

				/** TODO create notification and send message to admin  */
//				UserNotifications::setNotification($opportunity->owner_id, UserNotifications::TYPE_OPPORT_CREATE,
//					"You opportunity {$opportunity->title} has created", '', Url::to(['opportunities/insert-b?id='.$opportunity->id]));

				/** @var  User $owner */
				$owner = $opportunity->owner;

				/**
				 * TODO @event_mail Insert Opportunity event name - send message via mandrill
				 */
				/*$adminEmailUrl = Yii::$app->params['adminhost'].'/opportunities/check-opportunities?id='.$opportunity->id;
				$sendEmailResult = Yii::$app->mailer
				->compose('opportunitie-create',[
					'USERNAME' => $owner->username,
					'OPPORTNAME' => $opportunity->title,
					'URL' => $adminEmailUrl,
				])
				->setFrom([Yii::$app->params['adminEmail']=>Yii::$app->params['adminEmail']])
				->setTo(Yii::$app->params['adminEmail'])
				->send();*/
				$sendEmailResult = MailSender::sendToAdmin_CreateNewOpp($opportunity);

				return json_encode([
					'status' => 'OK',
					'context' => [
						'id' => $opportunity->id,
						'data' => json_decode(Yii::$app->request->post('data')),
					],
				]);
			}

			return json_encode([
				'status' => 'ERROR',
				'context' => [
					'validation' => $opportunity->validate(),
					'data' => json_decode(Yii::$app->request->post('data')),
				],
			]);

		}
		return json_encode([
			'status' => 'ERROR',
			'context' => '',
		]);
	}

	public function actionApiTeam(){
		if(Yii::$app->request->isPost && Yii::$app->request->post('data', false)){
			$data = json_decode(Yii::$app->request->post('data'));

			$opportunity = OpportunitiesModel::findOne((int)$data->opportunities_id);
			if($opportunity) {

				//Step A data save
				$opportunity->title = $data->title;
				$opportunity->description = $data->description;
				$start_date = $data->start_date_year.'-'.$data->start_date_month.'-1';
				$opportunity->start_date = strtotime($start_date);
				$opportunity->incorporation = $data->incorporation;
				$opportunity->main_markets = implode(',', $data->main_markets);
				$opportunity->site_url = $data->site_url;
				$opportunity->social_in_url = $data->social_in;
				$opportunity->social_fb_url = $data->social_fb;
				$opportunity->social_gp_url = $data->social_gp;
				$opportunity->basecamp = $data->basecamp;

				//Step B data save
				$opportunity->lifecycle_stage       = $data->lifecycle_stage;
				$opportunity->lifetime_rev_currency = $data->lifetime_rev_currency;
				$opportunity->lifetime_rev_value    = $data->lifetime_rev_value;
				$opportunity->last_rev_currency     = $data->last_rev_currency;
				$opportunity->last_rev_value        = $data->last_rev_value;
				$opportunity->opportunity_purpose   = $data->opportunity_purpose;
				$opportunity->status = OpportunitiesModel::STEP_B_CREATE;

				/* TODO проверяем создана ли у возможности команда */
				$team = $opportunity->team;
				if(!$team){
					/* TODO Если команда не создана создаём её  */
					$team = new Team();
					$team->name = substr($opportunity->title, 0, 21);
					$team->opportunity_id = $opportunity->id;
					$team->owner_id = $opportunity->owner_id;
					$team->description = $opportunity->description;
					$res = $team->save();
					OpportunitiesLogs::createOpportunityEvents($opportunity->id, OpportunitiesLogs::EVENT_OPPORTUNITY_TEAM_CREATE);

					/* TODO Создаём слак канал  */
					$slack_name = str_replace(' ', '-', strtolower(substr($team->name, 0, 30)));
//					$chanel_create_res = Slack::createChanelByName($slack_name);
					//Create chanel
					$chanel_create_res = RocketChatCT::createChanelByName($slack_name);

					/* if chanel create successful add slack id to DB  */
					if($chanel_create_res !== false){
						$team->slack_id = $chanel_create_res;
						$team->save();
						OpportunitiesLogs::createOpportunityEvents($opportunity->id, OpportunitiesLogs::EVENT_OPPORTUNITY_SLACK_CREATE);
						/* Add team owner to slack */
//						$owner_slack_res = Slack::addUsersToChanel($chanel_create_res, [$team->opportunity->owner->email]);
						//Add user to rocket chat group
						RocketChatCT::addUserToChanel($team->slack_id, $team->opportunity->owner->email);

					}
				}

				/* TODO сохраняем этап C */
				$opportunity->vision = $data->vision;
				$opportunity->proposition = $data->proposition;
				$opportunity->key_customer = $data->key_customer;
				$opportunity->target_markets = implode(',', $data->target_markets);
				$opportunity->interaction = $data->interaction;
				$opportunity->funding = $data->funding;

				if ( $opportunity->validate() && $opportunity->save() ) {
					/* TODO Добавляем остальных участников команды в слак  */
					$teamArray = ArrayHelper::map($data->team_members, 'user_id', 'user_id');
					$teamStatus = ArrayHelper::map($data->team_members, 'user_id', 'user_type');

					$returned_users = Team::updateOpportunityTeamList($team, $teamArray, TeamUser::STATUS_INVITED, $teamStatus);


					foreach ($returned_users['deleted'] as $item){
						/* TODO work with deleted users */
					}

					foreach ($returned_users['new'] as $item){
						/* TODO work with invited users */
						$user = User::findOne($item);

						OpportunitiesLogs::createOpportunityEvents($opportunity->id, OpportunitiesLogs::EVENT_OPPORTUNITY_MEMBER_INVITE, ['name' => $user->username.' '.$user->surname, 'url' => Url::to(['user/view?id='.$item])]);
						//TODO set correct url for check invitation
						$opportunity_url = Url::to(['opportunities/management/'.$opportunity->id]);
						UserNotifications::setNotification($item, UserNotifications::TYPE_TEAM_USER_INVITED,'','',$opportunity_url);
					}


					return json_encode( [
						'status'  => 'OK',
						'context' => [
							'id'   => $opportunity->id,
							'data' => json_decode( Yii::$app->request->post( 'data' ) ),
							'users' => $returned_users,
							'teamArray' => $teamArray,
							'team' => $res,

						],
					] );
				}
			}
			return json_encode([
				'status' => 'ERROR',
				'context' => [
					'validation' => $opportunity->validate(),
					'data' => json_decode(Yii::$app->request->post('data')),
				],
			]);

		}
		return json_encode([
			'status' => 'ERROR',
			'context' => '',
		]);
	}


	public function actionApiGetOpportunity(){
		if(Yii::$app->request->isPost && Yii::$app->request->post('id', false)){
			$opportunity = OpportunitiesModel::findOne(Yii::$app->request->post('id'));

			if($opportunity){

				$team = [];

				$teamModel = Team::find()->where(['opportunity_id' => $opportunity->id])->one();

				if($teamModel->users){

					$team_users = $teamModel->teamUser;

					/** @var TeamUser $team_user */
					foreach ($team_users as $team_user){
						$team[] = [
							'user_id' => $team_user->user->id,
		                    'user_name' => $team_user->user->username,
		                    'user_surname' => $team_user->user->surname,
		                    'user_email' => $team_user->user->email,
		                    'user_type' => $team_user->user_type,
		                    'user_img' => $team_user->user->myprofile->image,
						];

					}

				}


				return json_encode([
					'status' => 'OK',
					'context' => [
						'title' => $opportunity->title,
						'description' => $opportunity->description,
						'start_date_month' => date('n', $opportunity->start_date),
						'start_date_year' => date('Y', $opportunity->start_date),
						'incorporation' => $opportunity->incorporation,
						'basecamp' => $opportunity->basecamp,
						'main_markets' => explode(',', $opportunity->main_markets),
						'site_url' => $opportunity->site_url,
						'social_in' => $opportunity->social_in_url,
						'social_fb' => $opportunity->social_fb_url,
						'social_gp' => $opportunity->social_gp_url,
						'status' => $opportunity->status,
						'lifecycle_stage' => $opportunity->lifecycle_stage,
				        'lifetime_rev_currency' => $opportunity->lifetime_rev_currency,
				        'lifetime_rev_value' => $opportunity->lifetime_rev_value,
				        'last_rev_currency' => $opportunity->last_rev_currency,
				        'last_rev_value' => $opportunity->last_rev_value,
				        'opportunity_needs' => $opportunity->opportunity_purpose,
						'vision' => $opportunity->vision,
				        'proposition' => $opportunity->proposition,
				        'key_customer' => $opportunity->key_customer,
				        'interaction' => $opportunity->interaction,
				        'funding' => $opportunity->funding,
				        'target_markets' => explode(',', $opportunity->target_markets),
						'team' => $team,
					],
				]);
			}else{
				return json_encode([
					'status' => 'ERROR',
					'context' => Yii::$app->request->post(),
				]);
			}
		}
		return json_encode([
			'status' => 'ERROR',
			'context' => '',
		]);
	}

	public function actionApiCreateTemp(){
		if(Yii::$app->request->isPost && Yii::$app->request->post('data', false)){

			$data = json_decode(Yii::$app->request->post('data'));
			$opportunity = new OpportunitiesModel();
			$opportunity->title = $data->title;
			$opportunity->description = $data->description;
			$start_date = $data->start_date_year.'-'.$data->start_date_month.'-1';
			$opportunity->start_date = strtotime($start_date);
			$opportunity->incorporation = $data->incorporation;
			$opportunity->main_markets = implode(',', $data->main_markets);
			$opportunity->site_url = $data->site_url;
			$opportunity->social_in_url = $data->social_in;
			$opportunity->social_fb_url = $data->social_fb;
			$opportunity->social_gp_url = $data->social_gp;
			$opportunity->basecamp = $data->basecamp;
			$opportunity->owner_id = $data->owner_id;
			$opportunity->lifecycle_stage = $data->lifecycle_stage;
			$opportunity->lifetime_rev_currency = $data->lifetime_rev_currency;
			$opportunity->lifetime_rev_value = $data->lifetime_rev_value;
			$opportunity->last_rev_currency = $data->last_rev_currency;
			$opportunity->last_rev_value = $data->last_rev_value;
			$opportunity->opportunity_purpose = $data->opportunity_purpose;
			$opportunity->vision = $data->vision;
			$opportunity->proposition = $data->proposition;
			$opportunity->key_customer = $data->key_customer;
			$opportunity->target_markets = implode(',', $data->target_markets);
			$opportunity->interaction = $data->interaction;
			$opportunity->funding = $data->funding;
			$opportunity->status = OpportunitiesModel::UNACCEPTED;

			if($opportunity->validate() && $opportunity->save()){
				return json_encode([
					'status' => 'OK',
					'context' => [
						'id' => $opportunity->id,
						'data' => json_decode(Yii::$app->request->post('data')),
					],
				]);
			}

			return json_encode([
				'status' => 'ERROR',
				'context' => [
					'validation' => $opportunity->validate(),
					'data' => json_decode(Yii::$app->request->post('data')),
				],
			]);

		}
		return json_encode([
			'status' => 'ERROR',
			'context' => '',
		]);
	}

	/** Opportunity detail page */
	public function actionView($id){
    $opportunity = OpportunitiesModel::findOne($id);
    /** check user permission */
    if(!Team::checkUserInTeam($opportunity->team->id, Yii::$app->user->id)) $this->redirect(['profile/index']);

    return $this->render('view', compact('opportunity'));
	}

	/** Opportunity detail page for matching */
	public function actionMatchingView($id){
		$opportunity = OpportunitiesModel::findOne($id);

    /** check user permission
        if user admin or have added to this opport we redirect it to profile page
     */
    $team_id = $opportunity->team->id;
    $check_permission = Team::checkUserInTeam($team_id, Yii::$app->user->id) || Yii::$app->user->id == $opportunity->owner_id;
    if($check_permission) $this->redirect(['profile/my-team/'.$team_id]);

		return $this->render('view-matching', compact('opportunity'));
	}


	public function actionMatchingTalents($id){

    $opportunity = OpportunitiesModel::findOne($id);

    /** check user permission
    if user don't admin redirect it to profile page
     */
    $team_id = $opportunity->team->id;

    $check_permission = Team::checkUserInTeam($team_id, Yii::$app->user->id) && Yii::$app->user->id == $opportunity->owner_id;
    if(!$check_permission) $this->redirect(['profile/index']);

		$opportunity_talents = [];
		$users = User::find()->limit(10)->all();
		foreach ($users as $user){
			$opportunity_talents_obj = (object)[
				'user' => $user,
				'utc_fit_score' => random_int(90, 99),
				'drivers' => random_int(80, 99),
				'passions' => random_int(80, 99),
				'skills' => random_int(80, 99),
				'note' => 'Lorem ipsum dolor sit amet, consectetur adipisicing elit.',
				'professional_capabilities' => 'Capability '.random_int(1, 4),
				'human_centric' => 'Human-centric competencies '.random_int(1, 4),
				'enabling_competencies' => 'Competencies '.random_int(1, 4),
				'filter' => "",
			];
			$opportunity_talents_obj->filter = "'{$opportunity_talents_obj->professional_capabilities}','{$opportunity_talents_obj->enabling_competencies}','{$opportunity_talents_obj->human_centric}', {$user->id}";
			$opportunity_talents[] = $opportunity_talents_obj;
		}

//		$matching_opportunity = MatchingOpportunity::findOne(['opportunity_id' => $opportunity->id]);
		$matching_opportunity = MatchingOpportunity::find()->one();
		$matching_candidates = $matching_opportunity->matchingCandidates;

		/** Show filter */
		$pc_list = [];
		$ec_list = [];
		$hcc_list = [];

		/** @var MatchingCandidate $matching_candidate */
		foreach ( $matching_candidates as $matching_candidate) {
			/** @var array $skills */
			$skills = $matching_candidate->skills;

			if($skills){
				/** @var \common\models\tnd\MatchingCandidateSkills $skill */
				foreach ( $skills as $skill ) {
					if(stristr( $skill->skill, 'PC-') !== FALSE && !isset($pc_list[$skill->skill])){
						$pc_list[$skill->skill] = $skill->description;
					}elseif (stristr( $skill->skill, 'EC-') !== FALSE && !isset($ec_list[$skill->skill])){
						$ec_list[$skill->skill] = $skill->description;
					}elseif (stristr( $skill->skill, 'HC-') !== FALSE && !isset($hc_list[$skill->skill])){
						$hcc_list[$skill->skill] = $skill->description;
					}
				}
			}
		}

		return $this->render('talent-matching',
			compact('opportunity_talents', 'matching_candidates', 'pc_list', 'ec_list', 'hcc_list'));
	}

	/**
	 * Get user
	 * @param $id
	 *
	 * @return string
	 */
	public function actionGetUserData($id){
		if(Yii::$app->request->isAjax){
			$user = User::findOne($id);
			if($user){
				/** @var UserProfile $profile */
				$profile = $user->myprofile;
				/**
				 * Get team data
				 */
				$team_data = [];
				$team_id = Yii::$app->request->get('team_id', 0);
				if($team_id) {
					$teamuser = TeamUser::find()->where( [ 'user_id' => $id ] )->andWhere( [ 'team_id' => $team_id ] )->one();
					if($teamuser){
						$team_data = [
							'sharing_role' => $profile->sharing_role,
							'status' => $teamuser->status,
							'description' => $teamuser->description,
							'is_member' => $teamuser->isMember()?1:0,
							'is_leave'  => $teamuser->isLeave()?1:0,
							'is_delete' => $teamuser->isDelete()?1:0,
						];
					}
				}

				/**
				 * Get UTC data
				 */
				$utc_request_data = [];
				$utcdata = UserApiData::findOne(['user_id' => $id]);
				if($utcdata){
//					$utcdata = json_decode(ApiController::getUTCData($utcdata->utc_id));
					$utcdata = UtcObject::initFromJSON(ApiController::getUTCData($utcdata->utc_id));
					$utcdata->initRadarData(47);


					$utc_request_data = [
						'earth' => $utcdata->radar_earth,
						'water' => $utcdata->radar_water,
						'air' => $utcdata->radar_air,
						'fire' => $utcdata->radar_fire,
						'is_earth' => $utcdata->is_earth,
						'is_water' => $utcdata->is_water,
						'is_air' => $utcdata->is_air,
						'is_fire' => $utcdata->is_fire,
					];

				}
				$report_data = [];
				//$utcreportdata = ApiController::getReportData($user->internal_user_id, $user->getExternalId());
				if(true){
					//$utcreport = UtcReportObject::initFromJSON($utcreportdata);
					$utcdata->profile_skills_ec = [];
					$utcdata->profile_skills_pc = [];

					if($utcdata->skills) {
						foreach ( $utcdata->skills as $skills_item ) {
							if(stristr($skills_item->skill, 'EC-' ) !== false && (int)$skills_item->rank > 0){
								$utcdata->profile_skills_ec[(int)$skills_item->rank] = $skills_item->description;
							}
							if(stristr($skills_item->skill, 'PC-' ) !== false && (int)$skills_item->rank > 0){
								$utcdata->profile_skills_pc[(int)$skills_item->rank] = $skills_item->description;
							}
						}
						$utcdata->profile_skills_ec = array_values($utcdata->profile_skills_ec);
						ksort($utcdata->profile_skills_pc);
						$utcdata->profile_skills_pc = array_values($utcdata->profile_skills_pc);
					}

					$report_data = [
						'skills_ec' => $utcdata->profile_skills_ec,
						'skills_pc' => $utcdata->profile_skills_pc,
						'proff_skills' => $utcdata->profile_passions
					];
				}


				/** Che user rules */
				$manager_data_rules = new UserManagementDataRules($user);
				$current_user_consent = $manager_data_rules->checkSharingProfileConsent() || ($user->id == Yii::$app->user->id);
				if(!$current_user_consent){
					return json_encode( [
						'status'  => 'OK',
						'context' => [
							'id'   => $user->id,
							'name' => '',
							'surname' => '',
							'email' => '',
							'image' => $user->myprofile->image,
							'coding_level' => 3,
							'drivers_bar' => 0,
							'passions_bar' => 0,
							'skills_bar' => 0,
							'sharing_role' => $profile->sharing_role == ''?'fan':$profile->sharing_role,
							'utc' => [
								'earth' => 0,
								'water' => 0,
								'air' => 0,
								'fire' => 0,
								'is_earth' => 0,
								'is_water' => 0,
								'is_air' => 0,
								'is_fire' => 0,
							],
							'report_data' => $report_data,
							'team_data' => $team_data,
							'about' => $user->myprofile->presentazione_personale
						],
					] );
				}

				return json_encode( [
					'status'  => 'OK',
					'context' => [
						'id'   => $user->id,
						'name' => $user->username,
						'surname' => $user->surname,
						'email' => $user->email,
						'image' => $user->myprofile->image,
						'coding_level' => 3,
						'drivers_bar' => 0,
						'passions_bar' => 0,
						'skills_bar' => 0,
						'sharing_role' => $profile->sharing_role == ''?'fan':$profile->sharing_role,
						'utc' => $utc_request_data,
						'report_data' => $report_data,
						'team_data' => $team_data,
						'about' => $user->myprofile->presentazione_personale
					],
				] );
			}
		}
		//TODO default result
		return json_encode([
			'status' => 'ERROR',
			'context' => '',
		]);
	}

	public function actionApiMemberStatus(){
		$request = Yii::$app->request;
		if($request->isAjax && $request->isPost
		   && $request->post('status', false))
		{
			$status = $request->post('status');

			if($status === 'ADD'){
				$user_id = $request->post('user_id');
				$opportunity_id = $request->post('opportunity_id');
				OpportunitiesModel::addToWishList($opportunity_id, $user_id);
			}
			if($status === 'DEL'){
				$user_id = $request->post('user_id');
				$opportunity_id = $request->post('opportunity_id');
				OpportunitiesModel::delFromWishList($opportunity_id, $user_id);
			}
		}
	}

	/**
	 * Invite member to the team
	 * @return string
	 */
	public function actionApiInviteUser(){
		$request = Yii::$app->request;

		if($request->isAjax && $request->isPost){
			$user_id = $request->post('user_id');
			$team_id = $request->post('team_id');
			$user_type = $request->post('user_type');

			$user = User::findOne($user_id);
			$team = Team::findOne($team_id);
			$opportunity = $team->opportunity;

			if($user && $team && $user_type){

				$team_user = new TeamUser();
				$team_user->user_id = $user_id;
				$team_user->team_id = $team_id;
				$team_user->user_type = $user_type;
				$team_user->status = TeamUser::STATUS_INVITED;
				$team_user->save();

				if($team_user)

					/**
					 * TODO @event_mail Join_Opportunity event name - send message via mandrill
					 */
					/*$url = Yii::$app->params['host'].'/opportunities/view/'.$opportunity->id;

				$email_res = Yii::$app->mailer
				->compose('join-opportunity',[
					'USERNAME' => $user->username,
					'OWNERNAME' => $opportunity->owner->username,
					'OWNEREMAIL' => $opportunity->owner->email,
					'OPPORTNAME' => $opportunity->title,
					'URL' => $url
				])
				->setFrom([Yii::$app->params['adminEmail']=>Yii::$app->params['adminEmail']])
				->setTo($user->email)
				->send();*/
				$email_res = MailSender::sendToUser_JoinOppReq($user, $opportunity); //TODO GDPR features

				/**
				 *   TODO @event_notification Join_Opportunity A Opportunity Owner invite a user to Join an opportunity
				 */

				$title = "You are invited to join the Opportunity";
				$content = "You are invited to join the Opportunity {$opportunity->title}";
				$url = Url::to(['opportunities/view/'.$opportunity->id]);
				$notification_res = UserNotifications::setNotification($user_id, UserNotifications::TYPE_TEAM_USER_INVITED, $title, $content, $url);

				return json_encode( [
					'status'  => 'OK',
					'context' => [
						'team_user'   => $team_user->id,
					],
				] );
			}


		}

		return json_encode([
			'status' => 'ERROR',
			'context' => '',
		]);
	}

	public function actionApiInviteExternalUser(){
    $request = Yii::$app->request;

    if($request->isAjax && $request->isPost){
      $team_id = $request->post('team_id');
      $user_email = $request->post('user_email');
      $user_name = $request->post('user_name');
      $user_surname = $request->post('user_surname');
      $user_type = $request->post('user_type');

      if(!filter_var($user_email, FILTER_VALIDATE_EMAIL)){
          return json_encode([
            'status' => 'ERROR',
            'context' => '',
          ]);
      }

      $external_user = ExternalUser::findOne(['email'=>$user_email]);
      if(!$external_user){
        $external_user = new ExternalUser();
        $external_user->email = $user_email;
        $external_user->name = $user_name;
        $external_user->surname = $user_surname;
        $external_user->setDetails([
          'type' => $user_type,
        ]);
        $external_user->save();
      }

      $team_user = new TeamUser();
      $team_user->team_id = $team_id;
      $team_user->user_type = $user_type;
      $team_user->user_id = $external_user->id;
      $team_user->status = TeamUser::STATUS_INVITE_EXTERNAL;
      $team_user->save();

      $opportunity = $team_user->team->opportunity;

	    /*$url = Yii::$app->params['host'].'/opportunities/view/'.$opportunity->id;

		$email_res = Yii::$app->mailer
			->compose('invite-external',[
			'OWNERNAME' => $opportunity->owner->username,
			'OWNEREMAIL' => $opportunity->owner->email,
			'OPPORTNAME' => $opportunity->title,
			'URL' => $url
		])
		->setFrom([Yii::$app->params['adminEmail']=>Yii::$app->params['adminEmail']])
		->setTo($external_user->email)
		->send();*/

	    $email_res = MailSender::sendToExternalUser_JoinOppReq($external_user->email, $opportunity);

      return json_encode( [
        'status'  => 'OK',
        'context' => [
          'team_user'   => $team_user->id,
          'external_user'   => $external_user->id,
        ],
      ] );

    }

    return json_encode([
      'status' => 'ERROR',
      'context' => '',
    ]);
  }
}