namespace App\Services;

use DB,
    Auth;
use App\Models\Team;
use App\Models\User;
use App\Services\UserProjectPermissionManager\UserProjectPermissionManager;

class TeamService {

    public static function getStatusTypes() {
        return [
            Team::STATUS_ACTIVE => 'Active',
            Team::STATUS_INACTIVE => 'Inactive',
            Team::STATUS_LEFT => 'Left',
            'blocked' => 'Blocked',
        ];
    }

    public static function getRoleTypes() {
        return [
            Team::ROLE_OWNER => 'Owner',
            Team::ROLE_PROJECT_MANAGER => 'Project Manager',
            Team::ROLE_EXECUTIVE_MANAGER => 'Executive Manager',
            Team::ROLE_MEMBER => 'Employee',
            Team::ROLE_CLIENT => 'Client',
        ];
    }

    public static function getRoleInvitationTypes() {
        return [
            Team::ROLE_PROJECT_MANAGER => 'Project Manager',
            Team::ROLE_EXECUTIVE_MANAGER => 'Executive Manager',
            Team::ROLE_MEMBER => 'Employee',
        ];
    }

    public static function getTeamList() {
        return Team::join('users', function($join) {
                            $join->on('users.id', '=', 'owner_user_rel.owner_id');
                            $join->on('users.deleted_at', 'IS', \DB::raw('NULL'));
                        })
                        ->where('owner_user_rel.status', Team::STATUS_ACTIVE)
                        ->where('owner_user_rel.user_id', Auth::user()->id)
                        ->where('owner_user_rel.is_blocked', false)
                        ->groupBy('owner_user_rel.owner_id')
                        ->select([
                            DB::raw('CONCAT(users.team_name) as name'),
                            DB::raw('owner_user_rel.owner_id'),
                        ])->get();
    }



    public static function getProjectAvailableEmployeeList(Team $userTeamObj, $project_id) {
        $userArr = Team::join('project_user_rel', function($join) use($userTeamObj, $project_id) {
                    $join->on('project_user_rel.user_id', '=', 'owner_user_rel.user_id')
                    ->on('project_user_rel.project_id', '!=', \DB::raw($project_id))
                    ->on('project_user_rel.deleted_at', 'IS', \DB::raw('NULL'));
                    if ($userTeamObj->role == \App\Models\Team::ROLE_PROJECT_MANAGER || $userTeamObj->role == \App\Models\Team::ROLE_CLIENT) {
                        $user_permitted_projects_ids = $userTeamObj->permissions->lists('project_id')->toArray();
                        $join->whereIn('project_user_rel.project_id', $user_permitted_projects_ids);
                    }
                })
                ->notClient()
                ->leftJoin('users', 'users.id', '=', 'owner_user_rel.user_id')
                ->where('owner_user_rel.owner_id', $userTeamObj->owner_id)
                ->notBlocked()
                ->select([
            DB::raw('CONCAT(users.firstname, " ", users.lastname) as fullname'),
            DB::raw('owner_user_rel.user_id as user_id'),
        ]);
        $projectObj = \App\Models\Project::where('owner_id', $userTeamObj->owner_id)
                ->where('id', $project_id)
                ->firstOrFail();
        $userArr->whereNotIn('users.id', $projectObj->contracts->lists('user_id')->toArray());
        $userArr = $userArr->groupBy('owner_user_rel.user_id')->get();
        return $userArr;
    }

    public static function getFilteredMembers(Team $userTeamObj, array $filters = [], array $with = [], $trashed = false) {
        $user_projects_ids = [0];
        $user_permitted_projects_ids = [0];
        $userArr = User::join('owner_user_rel', function($join) use($userTeamObj, $trashed, $filters) {
                    $join->on('owner_user_rel.user_id', '=', 'users.id');
                    $join->where('owner_user_rel.owner_id', '=', $userTeamObj->owner_id);
                    $join->where('owner_user_rel.role', '!=', Team::ROLE_CLIENT);
                    if (!$trashed) {
                        $join->on('owner_user_rel.deleted_at', 'IS', \DB::raw('NULL'));
                    } else {
                        $join->on('owner_user_rel.deleted_at', 'IS NOT', \DB::raw('NULL'));
                    }
                    if (isset($filters['roles']) && count($filters['roles'])) {
                        $join->whereIn('owner_user_rel.role', $filters['roles']);
                    }
                });
        if (isset($filters['statuses']) && count($filters['statuses'])) {
            $blocked_index = array_search('blocked', $filters['statuses']);
            if ($blocked_index !== false) {
                unset($filters['statuses'][$blocked_index]);
                $userArr->where('owner_user_rel.is_blocked', true);
                if (count($filters['statuses'])) {
                    $userArr->whereIn('owner_user_rel.status', $filters['statuses']);
                }
            } else {
                $userArr->whereIn('owner_user_rel.status', $filters['statuses']);

            }
        }
        if (isset($filters['groups']) && count($filters['groups'])) {
            $userArr->join('user_groups', 'user_groups.user_id', '=', 'users.id');
            $userArr->whereIn('user_groups.group_id', $filters['groups']);
        }
        $userArr->leftJoin('project_user_rel', function($join) use($userTeamObj, $filters) {
            $join->on('project_user_rel.user_id', '=', 'users.id');
            $join->on('project_user_rel.deleted_at', 'IS', \DB::raw('NULL'));
        });
        if (isset($filters['projects']) && count($filters['projects'])) {
            $userArr->whereIn('project_user_rel.project_id', $filters['projects']);
        }
        if ($userTeamObj->role == \App\Models\Team::ROLE_CLIENT) {
            $user_permitted_projects_ids = $userTeamObj->permissions->lists('project_id')->toArray();
            $userArr->whereIn('project_user_rel.project_id', $user_permitted_projects_ids);
        } elseif ($userTeamObj->role == \App\Models\Team::ROLE_MEMBER || $userTeamObj->role == \App\Models\Team::ROLE_PROJECT_MANAGER) {
            $user_projects_ids = ContractService::getUserContractsList($userTeamObj, $userTeamObj->user_id, false, [
                        'projects.id' => 'project_id'
                    ])->lists('project_id')->toArray();
            $user_permitted_projects_ids = $userTeamObj->permissions->lists('project_id')->toArray();
            $userArr->whereIn('project_user_rel.project_id', array_merge($user_projects_ids, $user_permitted_projects_ids));
        }
        foreach ($with as $rel) {
            if ($rel == 'groups') {
                $rels['groups'] = function($query) use($userTeamObj) {
                    $query->where('groups.owner_id', $userTeamObj->owner_id);
                };
            } elseif ($rel == 'projects') {
                $rels['projects'] = function($query) use($userTeamObj, $user_projects_ids) {
                    $query->where('projects.owner_id', $userTeamObj->owner_id);
                    if ($userTeamObj->role == \App\Models\Team::ROLE_PROJECT_MANAGER || $userTeamObj->role == \App\Models\Team::ROLE_CLIENT) {
                        $user_permitted_projects_ids = $userTeamObj->permissions->lists('project_id')->toArray();
                        $query->whereIn('project_user_rel.project_id', $user_permitted_projects_ids);
                    } elseif ($userTeamObj->role == \App\Models\Team::ROLE_MEMBER) {
                        $query->whereIn('project_user_rel.project_id', $user_projects_ids);
                    }
                };
            }
        }
        if (count($with)) {
            $userArr->with($rels);
        }
        if (isset($filters['users'])) {
            $userArr->whereIn('users.id', $filters['users']);
        }
        $userArr->select([
            '*',
            DB::raw('users.id as id'),
            DB::raw('users.current_owner_id as current_owner_id'),

        ]);

        return $userArr->orderBy('owner_user.role', 'ASC')
                        ->orderBy('owner_user.created_at', 'ASC')
                        ->groupBy('users.id')->get();
    }

    public static function inviteMember($owner_id, $input_data = []) {
        $permissionManager = new UserProjectPermissionManager();
        $email = $input_data['email_add_member'];
        $firstname = $input_data['firstname_add_member'];
        $lastname = $input_data['lastname_add_member'];
        $role = $input_data['role_add_member'];
        $groups_str = $input_data['groups_add_member'];
        $invitedUserObj = User::withTrashed()->where('email', $email)->first();
        if (!$invitedUserObj) {
            $invitedUserObj = new User();
            $invitedUserObj->email = $email;
            $invitedUserObj->firstname = $firstname;
            $invitedUserObj->lastname = $lastname;
            $invitedUserObj->current_owner_id = $owner_id;
            $invitedUserObj->current_role = $role;
            $invitedUserObj->timezone = \Config::get('global.default_timezone');
            $invitedUserObj->team_name = $firstname . "'s team";
            $invitedUserObj->status = User::STATUS_INACTIVE;
            $invitedUserObj->password = '';
            \App\Models\Admin\MailingList::add($email, \App\Models\Admin\MailingList::TYPE_VISITOR);
            if (!$invitedUserObj->save()) {
                return false;
            }
            $teamObj = Team::create([
                        'owner_id' => $invitedUserObj->id,
                        'user_id' => $invitedUserObj->id,
                        'role' => Team::ROLE_OWNER,
                        'status' => Team::STATUS_INACTIVE,
            ]);
        }
        $token = md5($invitedUserObj->email . strtotime('now'));
        $confirmTokenObj = \App\Models\ConfirmToken::create([
                    'email' => $invitedUserObj->email,
                    'token' => $token,
                    'owner_id' => $owner_id,
                    'created_at' => date('Y-m-d H:i:s'),
        ]);
        if (!$confirmTokenObj) {
            return false;
        }
        $teamObj = Team::withTrashed()
                ->where('owner_id', $owner_id)
                ->where('user_id', $invitedUserObj->id)
                ->first();
        if ($teamObj) {
            if ($teamObj->trashed()) {
                $teamObj->update([
                    'role' => $role,
                    'deleted_at' => null
                ]);
            }
        } else {
            $teamObj = Team::create([
                        'owner_id' => $owner_id,
                        'user_id' => $invitedUserObj->id,
                        'role' => $role,
                        'status' => Team::STATUS_INACTIVE
            ]);
        }

        if ((int) $role === Team::ROLE_EXECUTIVE_MANAGER) {
            $permissionManager->setFullPermissionsToAllProjects($teamObj, $invitedUserObj);
        }

        \App\Services\NotificationService::createTeamNotification($teamObj, NotificationService::TYPE_TEAM_INVITED, false, [
            'confirmation_link' => \URL::to('accept-invitation', $token)
        ]);
        \App\Services\NotificationService::createRawNotification($owner_id, $owner_id, [
            'title' => 'Invitation sent',
            'body' => 'Your invitation has been sent',
        ]);
        \App\Services\TeamLogService::createTeamNotification($teamObj, TeamLogService::TYPE_TEAM_INVITED);
        \App\Services\UserService::syncGroups($invitedUserObj->id, $groups_str);
        $initiatorObj = User::find($owner_id);
        if ($invitedUserObj->status == User::STATUS_INACTIVE) {
            \App\Services\MailQueueService::createMailQueue($invitedUserObj, \App\Services\MailQueueService::TYPE_INVITE_NEW_USER, [
                'confirmation_link' => \URL::to('accept-invitation', $token),
                'fullname' => $initiatorObj->firstname . ' ' . $initiatorObj->lastname,
                'team_name' => $initiatorObj->team_name,
            ]);
        } else {
            \App\Services\MailQueueService::createMailQueue($invitedUserObj, \App\Services\MailQueueService::TYPE_INVITE_EXISTING_USER, [
                'confirmation_link' => \URL::to('accept-invitation', $token),
                'fullname' => $initiatorObj->firstname . ' ' . $initiatorObj->lastname,
                'team_name' => $initiatorObj->team_name,
            ]);
        }
        return true;
    }

    public static function inviteClient(User $ownerObj, $input_data = []) {
        $email = $input_data['email_add_client'];
        $firstname = $input_data['firstname_add_client'];
        $lastname = $input_data['lastname_add_client'];
        $invitedUserObj = User::withTrashed()->where('email', $email)->first();
        if (!$invitedUserObj) {
            $invitedUserObj = new User();
            $invitedUserObj->email = $email;
            $invitedUserObj->firstname = $firstname;
            $invitedUserObj->lastname = $lastname;
            $invitedUserObj->current_owner_id = $ownerObj->id;
            $invitedUserObj->current_role = Team::ROLE_CLIENT;
            $invitedUserObj->timezone = \Config::get('global.default_timezone');
            $invitedUserObj->team_name = $firstname . "'s team";
            $invitedUserObj->status = User::STATUS_INACTIVE;
            $invitedUserObj->password = '';
            \App\Models\Admin\MailingList::add($email, \App\Models\Admin\MailingList::TYPE_VISITOR);
            if (!$invitedUserObj->save()) {
                return false;
            }
            $teamObj = Team::create([
                        'owner_id' => $invitedUserObj->id,
                        'user_id' => $invitedUserObj->id,
                        'role' => Team::ROLE_OWNER,
                        'status' => Team::STATUS_INACTIVE,
            ]);
        }
        $token = md5($invitedUserObj->email . strtotime('now'));
        $confirmTokenObj = \App\Models\ConfirmToken::create([
                    'email' => $invitedUserObj->email,
                    'token' => $token,
                    'owner_id' => $ownerObj->id,
                    'created_at' => date('Y-m-d H:i:s'),
        ]);
        if (!$confirmTokenObj) {
            return false;
        }
        $teamObj = Team::withTrashed()
                ->where('owner_id', $ownerObj->id)
                ->where('user_id', $invitedUserObj->id)
                ->first();
        if ($teamObj) {
            if (!$teamObj->trashed()) {
                return false;
            }
            $teamObj->restore();
            $query = 'UPDATE `project_user_rel` INNER JOIN `projects` ON `projects`.`id` = `project_user_rel`.`project_id` AND `projects`.`owner_id` = ? SET `project_user_rel`.`deleted_at` = ?,`project_user_rel`.`updated_at` = ? WHERE `project_user_rel`.`deleted_at` IS NULL AND `user_id` = ?';
            \DB::delete($query, [
                $ownerObj->id,
                date('Y-m-d H:i:s'),
                date('Y-m-d H:i:s'),
                $invitedUserObj->id
            ]);
            $teamObj->update([
                'role' => Team::ROLE_CLIENT,
                'status' => Team::STATUS_ACTIVE
            ]);
        } else {
            $teamObj = Team::create([
                        'owner_id' => $ownerObj->id,
                        'user_id' => $invitedUserObj->id,
                        'role' => Team::ROLE_CLIENT,
                        'status' => Team::STATUS_INACTIVE,
            ]);
        }
        \App\Services\NotificationService::createTeamNotification($teamObj, NotificationService::TYPE_TEAM_INVITED, false, [
            'confirmation_link' => \URL::to('accept-invitation', $token)
        ]);
        \App\Services\NotificationService::createRawNotification($ownerObj->id, $ownerObj->id, [
            'title' => 'Invitation sent',
            'body' => 'Your invitation has been sent',
        ]);
        \App\Services\TeamLogService::createTeamNotification($teamObj, TeamLogService::TYPE_TEAM_INVITED);
        if ($invitedUserObj->status == User::STATUS_INACTIVE) {
            \App\Services\MailQueueService::createMailQueue($invitedUserObj, \App\Services\MailQueueService::TYPE_INVITE_NEW_CLIENT, [
                'confirmation_link' => \URL::to('accept-invitation', $token),
                'fullname' => $ownerObj->firstname . ' ' . $ownerObj->lastname,
                'team_name' => $ownerObj->team_name,
            ]);
        } else {
            \App\Services\MailQueueService::createMailQueue($invitedUserObj, \App\Services\MailQueueService::TYPE_INVITE_EXISTING_CLIENT, [
                'confirmation_link' => \URL::to('accept-invitation', $token),
                'fullname' => $ownerObj->firstname . ' ' . $ownerObj->lastname,
                'team_name' => $ownerObj->team_name,
            ]);
        }
        return true;
    }

    public static function getTeamDropdownList() {
        return Team::active()->where('user_id', Auth::user()->id)->with(['owner'])
                        ->where('is_blocked', false)
                        ->get();
    }

    public static function syncNotifications($user_id, $notification_ids) {
        $existing_notification_ids = Team::where('user_id', $user_id)
                        ->where('notifications', true)
                        ->active()->notBlocked()
                        ->get()->lists('id')->toArray();
        $add = array_diff($notification_ids, $existing_notification_ids);
        $remove = array_diff($existing_notification_ids, $notification_ids);
        if ($add) {
            Team::whereIn('id', $add)->update([
                'notifications' => true
            ]);
        }
        if ($remove) {
            Team::whereIn('id', $remove)->update([
                'notifications' => false
            ]);
        }
        return true;
    }

    public static function canAddUser($owner_id) {
        $userObj = \App\Models\User::findOrFail($owner_id);
        $teamObj = Team::where('owner_id', $owner_id)
                        ->notBlocked()
                        ->where('role', '!=', Team::ROLE_CLIENT)
                        ->whereIn('status', [Team::STATUS_ACTIVE, Team::STATUS_INACTIVE])
                        ->select([
                            \DB::raw('COUNT(*) as  count')
                        ])->first();
        if (!$userObj->subscription) {
            if ($teamObj->count >= \Config::get('global.free_users_limit')) {
                return false;
            }
        } else {
            if ($teamObj->count >= $userObj->subscription->max_users) {
                return false;
            }
        }
        return true;
    }

    public static function switchToFreePlan($owner_id) {
        $availabale_team_ids = Team::where('owner_id', $owner_id)
                        ->notBlocked()
                        ->whereIn('status', [Team::STATUS_ACTIVE, Team::STATUS_INACTIVE])
                        ->orderBy('role', 'ASC')
                        ->orderBy('status', 'ASC')
                        ->limit(\Config::get('global.free_users_limit'))
                        ->lists('id')->toArray();
        $teamArr = Team::where('owner_id', $owner_id)
                ->whereNotIn('id', $availabale_team_ids)
                ->notBlocked()
                ->whereIn('status', [Team::STATUS_ACTIVE, Team::STATUS_INACTIVE])
                ->with(['employee'])
                ->get();
        foreach ($teamArr as $teamObj) {
            $teamObj->block();
        }
    }

    public static function getFilteredClients(Team $userTeamObj, array $filters = [], $trashed = false) {
        $clientTeamArr = Team::where('owner_user_rel.owner_id', '=', $userTeamObj->owner_id);
        $clientTeamArr->where('owner_user_rel.role', Team::ROLE_CLIENT);
        $clientTeamArr->join('users', 'owner_user_rel.user_id', '=', 'users.id');
        if ($trashed) {
            $clientTeamArr->onlyTrashed();
        }

        if (isset($filters['statuses']) && count($filters['statuses'])) {
            $blocked_index = array_search('blocked', $filters['statuses']);
            if ($blocked_index !== false) {
                unset($filters['statuses'][$blocked_index]);
                $clientTeamArr->where('owner_user_rel.is_blocked', true);
                if (count($filters['statuses'])) {
                    $clientTeamArr->whereIn('owner_user_rel.status', $filters['statuses']);
                }
            } else {
                $clientTeamArr->whereIn('owner_user_rel.status', $filters['statuses']);
            }
        }

        if (isset($filters['groups']) && count($filters['groups'])) {
            $clientTeamArr->join('user_groups', 'user_groups.user_id', '=', 'users.id');
            $clientTeamArr->whereIn('user_groups.group_id', $filters['groups']);
        }

        $clientTeamArr->leftJoin('project_permissions', function($join) use($userTeamObj, $filters) {
            $join->on('project_permissions.owner_user_rel_id', '=', 'owner_user_rel.id');
        });
        $clientTeamArr->where('owner_user_rel.owner_id', '=', $userTeamObj->owner_id);
        if (isset($filters['projects']) && count($filters['projects'])) {
            $clientTeamArr->where(function($query) use($filters) {
                $query->whereIn('project_permissions.project_id', $filters['projects']);
            });
        }

        $clientTeamArr->with([
            'employee.groups' => function($query) use($userTeamObj) {
                $query->where('groups.owner_id', $userTeamObj->owner_id);
            },
            'permissions.project' => function($query) use($userTeamObj) {
                $query->where('projects.owner_id', $userTeamObj->owner_id);
            },
        ]);

        $clientTeamArr->select([
            'owner_user_rel.*',
        ]);

        return $clientTeamArr->groupBy('users.id')->orderBy('owner_user_rel.created_at', 'DESC')->get();
    }

    public static function changeRateStatus($team_id, $rate_status) {
        $team = Team::find($team_id);

        if ($team) {
            if ('true' === $rate_status) {
                $team->rate_status = Team::SHOW_RATE;
            } elseif ('false' === $rate_status) {
                $team->rate_status = Team::HIDE_RATE;
            }
            $team->save();

            return true;
        }

        return false;
    }

}