<?php

namespace App\Komma\Commands;


use App\Komma\Users\User;
use Carbon\Carbon;
use App\Komma\ActivityLog\Activity;
use App\Komma\Companies\Company;
use App\Komma\Hours\Hour;
use App\Komma\Notifications\NotificationService;
use App\Komma\Projects\Project;
use App\Komma\Projects\ProjectService;
use App\Komma\ProjectWorkers\ProjectWorker;
use App\Komma\Settings\AbsenceBalances\AbsenceBalance;
use App\Komma\Settings\AbsenceBalances\AbsenceBalanceService;
use App\Komma\Settings\AbsenceTypes\AbsenceType;
use App\Komma\Settings\ProjectTemplates\ProjectTemplate;
use App\Komma\Settings\Subprojecttemplates\SubprojectTemplate;
use App\Komma\Subprojects\Subproject;
use App\Komma\Tasks\Task;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class CommandsService
{
    protected $projectService;
    protected $notificationService;
    protected $absenceBalanceService;

    public function __construct(ProjectService $projectService, NotificationService $notificationService, AbsenceBalanceService $absenceBalanceService)
    {
        $this->projectService = $projectService;
        $this->notificationService = $notificationService;
        $this->absenceBalanceService = $absenceBalanceService;
    }

    /**
     * @param $collection
     */
    public function cleanupDelete($collection, $model)
    {
        foreach ($collection as $item) {
            //find activities of item
            $activities = Activity::where('subject_type', $model)->where('subject_id', $item->id)->get();
            //delete activities
            foreach ($activities as $activity) {
                //delete
                $activity->forceDelete();
            }

            //try delete item
            try {
                $model = new $model;
                //delete
                $model->withTrashed()->find($item->id)->forceDelete();

            } catch (\Exception $e) {
                //store error
                \Log::error($e);
            }
        }
    }


    /**
     * @param $activities
     */
    public function cleanupActivities($activities)
    {
        foreach ($activities as $activity) {
            $activity->forceDelete();
        }
    }


    /**
     * @param $collection
     */
    public function deleteTasks($collection)
    {
        //loop trough task collection
        foreach ($collection as $task) {

            //find all hours
            $hours = Hour::withTrashed()->where('task_id', $task->id)->get();
            //loop trough hours
            foreach ($hours as $hour) {
                //delete hour
                $hour->forceDelete();
            }

            //delete task
            $task->forceDelete();
        }
    }


    /**
     * @param $collection
     */
    public function deleteSubprojects($collection)
    {
        //loop trough subprojects collection
        foreach ($collection as $subproject) {

            //find all tasks
            $tasks = Task::withTrashed()->where('subproject_id', $subproject->id)->get();

            //delete tasks
            $this->deleteTasks($tasks);

            //delete subproject
            $subproject->forceDelete();
        }
    }


    /**
     * @param $collection
     */
    public function deleteProjects($collection)
    {
        //loop trough projects collection
        foreach ($collection as $project) {

            //find all subprojects
            $subprojects = Subproject::withTrashed()->where('project_id', $project->id)->get();

            //delete subprojects
            $this->deleteSubprojects($subprojects);

            //delete project
            Project::withTrashed()->find($project->id)->forceDelete();
        }
    }


    /**
     * @param $collection
     */
    public function deleteCompanies($collection)
    {
        //loop trough projects collection
        foreach ($collection as $company) {

            //find all subprojects
            $projects = Project::where('company_id', $company->id)->get();

            //delete subprojects
            $this->deleteProjects($projects);

            //get contacts information
            $companyModel = Company::find($company->id);

            if(!isset($companyModel)) abort(422, self::class .': Unknown company:' . $company->id);
            $contacts = $companyModel->Contacts;

            //loop trough contacts
            foreach ($contacts as $contact) {
                //delete contact
                $contact->forceDelete();
            }

            //delete project
            $company->forceDelete();
        }
    }


    /**
     * @param $projects
     */
    public function autoGenerateProjects($command, $projects)
    {
        //loop trough projects
        foreach ($projects as $project) {
            $month = $project->created_at->month+1;
            if ($month > 12) $month = $month - 12;

            //check which project must created
            if ($month == Carbon::now()->month) {
                $this->createProject($command, $project);
                $command->info('New project created :) ');
                $project->name = explode(' (', $project->name)[0] . Carbon::today()->format(' (d-m-Y)');
                $project->archived = '1';
                $project->save();

                $this->notificationService->archivedNotification($project);
            } else {
                $command->info('Project needs to be generated at month '.$month.'. It is now month '. Carbon::now()->month);
            }
        }
    }


    /**
     * @param $oldProject
     */
    public function createProject($command, $oldProject)
    {
        \DB::transaction(function () use ($oldProject, $command) {
            if ($oldProject->create_every_x_months == 1) $nameDate = Carbon::today()->formatLocalized(' | %B %Y');
            else $nameDate = Carbon::today()->format(' | Y-Q' . Carbon::today()->quarter);
            $command->info('creating new project');
            $name = explode(' |', $oldProject->name)[0] . $nameDate;
            $command->info('new name = '.$name);
            //store project
            $project = new Project();
            $project->company_id = $oldProject->company_id;
            $project->project_template_id = $oldProject->project_template_id;
            $project->name = $name;
            $project->hourly_rate = $oldProject->hourly_rate;
            $project->billable = $oldProject->billable;
            $project->reserved = $oldProject->reserved;
            $project->create_every_x_months = $oldProject->create_every_x_months;
            $project->save();
            $command->info('project saved');

            //make user project owner
            $projectWorker = new ProjectWorker();
            $projectWorker->project_id = $project->id;
            $projectWorker->user_id = $oldProject->ProjectWorkers()->first()->user_id;
            $projectWorker->role_id = 1;
            $projectWorker->save();
            $command->info('projectworker saved');

            $subprojectTemplate = SubprojectTemplate::where('name', '=', 'Projectmanagement')->first();

            if(!empty($subprojectTemplate)) {

                $billable = $subprojectTemplate->standard_billable;

                if($oldProjectManagement = $oldProject->Subprojects->where('subproject_template_id', '=', 1)->first()) {
                    $billable = $oldProjectManagement->billable;
                }

                $subprojectArray = [
                    'name' => $subprojectTemplate->name,
                    'budget' => $subprojectTemplate->buget,
                    'hourlyRate' => $subprojectTemplate->hourly_rate,
                    'billable' => $billable,
                ];

                $this->projectService->storeRelatedSubproject(null, $subprojectArray, $subprojectTemplate, $project,
                    $subprojectTemplate->budget);
            }
        });
    }


    /**
     * @param $year
     */
    public function autoGenerateBalances($year)
    {
        $types = AbsenceType::where('has_balance', '1')->get();
        foreach ($types as $type) {
            $this->absenceBalanceService->generateBalance($type, $year);
        }
    }

    public function autoGenerateTotalWorkInProgressAndHoursLeftInBudget(){
        $projects = Project::where('calculated', '='. 0)->get();

        $totalWorkInProgress = 0;
        $totalBudgetLeft = 0;
        foreach($projects as $project) {
            $budgets = (object)$this->projectService->getBudgets($project);
            if($budgets->projectHours['budget'] > 0 && $project->billable == 1) {
                $totalBudgetLeft += $budgets->projectHours['hoursLeftInBudget'];

                $weightedAverageHourlyRate = $this->projectService->weightedAverageHourlyRate($project);
                $billableBudget = $project->Subprojects->where('billable', 1)->sum('budget');
                $sumExpense = (object)$this->projectService->sumExpenses($project);
                $workInProgress = floatval($weightedAverageHourlyRate*($billableBudget+$budgets->projectHours['totalBillWithoutBudget'])  + $sumExpense->total ) - (!empty($project->billed_amount) ? $project->billed_amount : 0);
                $totalWorkInProgress += $workInProgress;
//                Log::debug('project ID '.$project->id.' => workInProgress: '. $workInProgress .' = '. $totalWorkInProgress);
            }
        }

        DB::table('statistics')
            ->updateOrInsert(
                ['date' => Carbon::today()->format('Y-m-d')],
                ['updated_at' => Carbon::now()->toTimeString(),
                    'totalBudgetLeft' => round($totalBudgetLeft, 2),
                'totalWorkInProgress' => round($totalWorkInProgress, 2)]
            );
    }

}