sfp_api_laravel_diarista/app/Services/ScheduleService.php

<?php

namespace App\Services;

use App\Jobs\FinishScheduleJob;
use App\Jobs\StartScheduleJob;
use App\Models\Schedule;
use App\Models\Provider;
use App\Models\ProviderBlockedDay;
use App\Models\ProviderWorkingDay;
use App\Rules\ScheduleBusinessRules;
use Carbon\Carbon;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class ScheduleService
{
  private const EXCLUDED_STATUSES = ['cancelled', 'rejected'];

  public function getAll()
  {
    return Schedule::with(['client.user', 'provider.user', 'address'])
      ->where('schedule_type', 'default')
      ->orderBy('date', 'desc')
      ->orderBy('start_time', 'desc')
      ->get();
  }

  public function getFinished()
  {
    return Schedule::with(['client.user', 'provider.user'])
      ->where('status', 'finished')
      ->orderBy('date', 'desc')
      ->orderBy('start_time', 'desc')
      ->get();
  }

  public function getById($id)
  {
    return Schedule::with(['client.user', 'provider.user', 'address'])->findOrFail($id);
  }

  public function createSingleOrMultiple(array $baseData, array $schedules)
  {
    try {
      DB::beginTransaction();
      $createdSchedules = [];
      foreach ($schedules as $schedule) {
        $datasMerged = array_merge($baseData, $schedule);
        $this->validateProviderAvailability($datasMerged, null);
        $scheduleData = array_merge($datasMerged, [
          'code' => str_pad(random_int(0, 9999), 4, '0', STR_PAD_LEFT),
        ]);
        $createdSchedules[] = Schedule::create($scheduleData);
      }
      DB::commit();
    } catch (\Exception $e) {
      DB::rollBack();
      throw new \Exception(__($e->getMessage()));
    }

    return $createdSchedules;
  }

  public function update($id, array $data)
  {
    $schedule = Schedule::findOrFail($id);

    if (isset($data['provider_id']) || isset($data['period_type'])) {
      $providerId = $data['provider_id'] ?? $schedule->provider_id;
      $periodType = $data['period_type'] ?? $schedule->period_type;
      $provider = Provider::findOrFail($providerId);
      $data['total_amount'] = $this->calculateAmount($provider, $periodType);
    }

    if (isset($data['date']) || isset($data['start_time']) || isset($data['provider_id'])) {
      $validationData = array_merge($schedule->toArray(), $data);
      $this->validateProviderAvailability($validationData, $id);
    }

    $schedule->update($data);
    return $schedule->fresh(['client.user', 'provider.user', 'address']);
  }

  public function delete($id)
  {
    $schedule = Schedule::findOrFail($id);
    $schedule->delete();
    return $schedule;
  }

  private function calculateAmount(Provider $provider, string $periodType): float
  {
    $hourlyRates = [
      '2' => $provider->daily_price_2h ?? 0,
      '4' => $provider->daily_price_4h ?? 0,
      '6' => $provider->daily_price_6h ?? 0,
      '8' => $provider->daily_price_8h ?? 0,
    ];

    return $hourlyRates[$periodType] ?? 0;
  }

  private function validateProviderAvailability(array $data, $excludeScheduleId = null)
  {
    $provider_id = $data['provider_id'];
    $client_id = $data['client_id'];

    $date = Carbon::parse($data['date']);
    $dayOfWeek = $date->dayOfWeek;
    $startTime = $data['start_time'];
    $endTime = $data['end_time'];
    $date_ymd = $date->format('Y-m-d');
    $period = $startTime < '13:00:00' ? 'morning' : 'afternoon';

    // bloqueio 2 schedules por semana para o mesmo client e provider
    ScheduleBusinessRules::validateWeeklyScheduleLimit(
      $client_id,
      $provider_id,
      $data['date'],
      $excludeScheduleId
    );

    // bloqueio provider trabalha no dia/periodo
    ScheduleBusinessRules::validateWorkingDay(
      $provider_id,
      $dayOfWeek,
      $period
    );
    
    // bloqueio provider tem blockedday para dia/hora
    ScheduleBusinessRules::validateBlockedDay(
      $provider_id,
      $date->format('Y-m-d'),
      $startTime,
      $endTime
    );
    
    // bloqueio provider tem outro agendamento para dia/hora
    ScheduleBusinessRules::validateConflictingSchedule(
      $provider_id,
      $date->format('Y-m-d'),
      $startTime,
      $endTime,
      $excludeScheduleId
    );

    // bloqueio provider tem outra proposta na mesma data
    ScheduleBusinessRules::validateConflictingProposalSameDate(
      $provider_id,
      $date_ymd,
      $startTime,
      $endTime,
      null
    );

    // bloqueio caso o client tenha bloqueado o provider
    ScheduleBusinessRules::validateClientNotBlockedByProvider(
      $client_id,
      $provider_id
    );

    // bloqueio caso o provider tenha bloqueado o client
    ScheduleBusinessRules::validateProviderNotBlockedByClient(
      $client_id,
      $provider_id
    );
    
    return true;
  }

  public function getSchedulesDefaultGroupedByClient()
  {
    $schedules = Schedule::with(['client.user', 'provider.user', 'address', 'reviews.reviewsImprovements.improvementType'])
      ->orderBy('id', 'desc')
      ->where('schedule_type', 'default')
      ->select(
        'schedules.*'
      )
      ->get();

    $grouped = $schedules->groupBy('client_id')->map(function ($clientSchedules) {
      $firstSchedule = $clientSchedules->first();
      return [
        'client_id' => $firstSchedule->client_id,
        'client_name' => $firstSchedule->client->user->name ?? 'N/A',
        'schedules' => $clientSchedules->map(function ($schedule) {
          return [
            'id' => $schedule->id,
            'date' => $schedule->date ? Carbon::parse($schedule->date)->format('d/m/Y') : null,
            'start_time' => $schedule->start_time,
            'end_time' => $schedule->end_time,
            'period_type' => $schedule->period_type,
            'status' => $schedule->status,
            'total_amount' => $schedule->total_amount,
            'code' => $schedule->code,
            'code_verified' => $schedule->code_verified,
            'client_id' => $schedule->client_id,
            'provider_id' => $schedule->provider_id,
            'provider_name' => $schedule->provider->user->name ?? 'N/A',
            'address' => $schedule->address ? [
              'id' => $schedule->address->id,
              'address' => $schedule->address->address,
              'complement' => $schedule->address->complement,
              'zip_code' => $schedule->address->zip_code,
              'city' => $schedule->address->city->name ?? '',
              'state' => $schedule->address->city->state->name ?? '',
            ] : null,
            'client_name' => $schedule->client->user->name ?? 'N/A',
            'reviews' => $schedule->reviews->map(function ($review) {
              return [
                'id' => $review->id,
                'stars' => $review->stars,
                'comment' => $review->comment,
                'origin' => $review->origin,
                'origin_id' => $review->origin_id,
                'created_at' => Carbon::parse($review->created_at)->format('Y-m-d H:i'),
                'updated_at' => Carbon::parse($review->updated_at)->format('Y-m-d H:i'),
                'improvements' => $review->reviewsImprovements->map(function ($ri) {
                  return [
                    'id' => $ri->id,
                    'improvement_type_id' => $ri->improvement_type_id,
                    'improvement_type_name' => $ri->improvementType ? $ri->improvementType->description : null,
                  ];
                })->values(),
              ];
            })
          ];
        })->values()
      ];
    })->sortBy('id')->values();

    return $grouped;
  }

  public function updateStatus($id, string $status)
  {
    try {
      DB::beginTransaction();
      $schedule = Schedule::findOrFail($id);
  
      $allowedTransitions = [
        'pending' => ['accepted', 'rejected'],
        'accepted' => ['paid', 'cancelled'],
        'paid' => ['cancelled', 'started'],
        'started' => ['finished'],
        'rejected' => [],
        'cancelled' => [],
        'finished' => [],
      ];
  
      $currentStatus = $schedule->status;
  
      if (!isset($allowedTransitions[$currentStatus])) {
        throw new \Exception("Status atual inválido.");
      }
  
      if (!in_array($status, $allowedTransitions[$currentStatus])) {
        throw new \Exception("Transição de status não permitida: {$currentStatus} → {$status}");
      }
  
      $schedule->update(['status' => $status]);
  
      switch ($status) {
        case 'pending':
          break;
        case 'accepted':
          break;
        case 'rejected':
          break;
        case 'paid':
          $date_cleaned = Carbon::parse($schedule->date)->format('Y-m-d');
          $date_time_dispatch = Carbon::parse($date_cleaned . ' ' . $schedule->start_time);

          // StartScheduleJob::dispatch($schedule->id)->delay($date_time_dispatch);

          // dispatch de teste em local
          StartScheduleJob::dispatch($schedule->id)->delay(now()->addSeconds(15));
          break;
        case 'cancelled':
          break;
        case 'started':
          break;
        case 'finished':
          break;
      }
      
      DB::commit();
      return $schedule->fresh(['client.user', 'provider.user', 'address']);
    } catch (\Exception $e) {
      DB::rollBack();
      Log::error("Erro ao atualizar status do agendamento: " . $e->getMessage());
      throw new \Exception("Não foi possível atualizar o status do agendamento.");
    }
  }

  public function cancelWithReason(int $id, string $cancelText)
  {
    try {
      DB::beginTransaction();
      $schedule = Schedule::findOrFail($id);

      $allowedStatuses = ['accepted', 'paid'];
      if (!in_array($schedule->status, $allowedStatuses)) {
        throw new \Exception("Cancelamento não permitido para o status atual: {$schedule->status}");
      }

      $cancelled_by = Auth::user()->type;

      $schedule->update([
        'status'      => 'cancelled',
        'cancel_text' => $cancelText,
        'cancelled_by' => $cancelled_by,
      ]);

      DB::commit();
      return $schedule->fresh(['client.user', 'provider.user', 'address']);
    } catch (\Exception $e) {
      DB::rollBack();
      Log::error("Erro ao cancelar agendamento: " . $e->getMessage());
      throw new \Exception("Não foi possível cancelar o agendamento.");
    }
  }
          public function getClientProviderBlocks(int $clientId, int $providerId): array
  {
    $today = Carbon::today()->format('Y-m-d');

    $schedules = Schedule::where('client_id', $clientId)
      ->where('provider_id', $providerId)
      ->whereNotIn('status', self::EXCLUDED_STATUSES)
      ->whereDate('date', '>=', $today)
      ->orderBy('date')
      ->orderBy('start_time')
      ->get(['id', 'date', 'start_time', 'end_time', 'status']);

    $existingSchedules = $schedules->map(function ($schedule) {
      return [
        'id' => $schedule->id,
        'date' => Carbon::parse($schedule->date)->format('Y-m-d'),
        'start_time' => $schedule->start_time,
        'end_time' => $schedule->end_time,
        'status' => $schedule->status,
      ];
    })->values();

    $fullyBlockedWeeks = $schedules
      ->groupBy(function ($schedule) {
        return Carbon::parse($schedule->date)
          ->startOfWeek(Carbon::SUNDAY)
          ->format('Y-m-d');
      })
      ->filter(function ($weekSchedules) {
        return $weekSchedules->count() >= 2;
      })
      ->keys()
      ->values();

    return [
      'existing_schedules' => $existingSchedules,
      'fully_blocked_weeks' => $fullyBlockedWeeks,
    ];
  }
}