<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Models\Appointment;
use App\Models\Client;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use App\Models\Holiday;

class AppointmentController extends Controller
{
    /**
     * Check if user has access to create appointments
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function checkCreateAppointmentAccess(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'customer_id' => 'required|exists:clients,id'
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => $validator->errors()
            ], 422);
        }

        try {
            $user = $request->user();
            $client = Client::findOrFail($request->customer_id);
            
            // Check if user is active
            if ($user->status_id != 1) {
                return response()->json([
                    'success' => false,
                    'message' => 'Account is not active',
                    'has_access' => false
                ], 403);
            }

            // Check if client has appointment access
            $hasAccess = $client->is_appointment == 1 ? true : false;

            return response()->json([
                'success' => true,
                'message' => 'Access check completed',
                'has_access' => $hasAccess,
                'client' => [
                    'id' => $client->id,
                    'name' => $client->name,
                    'is_appointment' => $client->is_appointment == 1 ? true : false
                ]
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error checking access: ' . $e->getMessage(),
                'has_access' => false
            ], 500);
        }
    }
    
    public function checkAppointmentDate(Request $request)
    {
        // Validation
        $validator = Validator::make($request->all(), [
            'appointment_date' => 'required|date|after_or_equal:today'
        ]);
 
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => $validator->errors()
            ], 422);
        }
 
        try {
            // Format date (optional)
            $appointmentDate = \Carbon\Carbon::parse($request->appointment_date)->format('Y-m-d');
 
            // Check if date is today or future
            if ($appointmentDate < date('Y-m-d')) {
                return response()->json([
                    'success' => false,
                    'message' => 'Appointment date is not valid',
                    'is_valid' => false
                ], 422);
            }
 
            // Check holiday
            $checkInHoliday = Holiday::where('holiday_date', $appointmentDate)
                ->where('is_active', true)
                ->first();
 
            if ($checkInHoliday) {
                return response()->json([
                    'success' => false,
                    'message' => 'Selected date is a holiday',
                    'is_valid' => false,
                    'holiday_name' => $checkInHoliday->holiday_name
                ], 422);
            }
 
            // Success response
            return response()->json([
                'success' => true,
                'message' => 'Appointment date is valid',
                'is_valid' => true,
                'formatted_date' => \Carbon\Carbon::parse($appointmentDate)->format('d-m-Y')
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error checking appointment date: ' . $e->getMessage(),
                'is_valid' => false
            ], 500);
        }
    }

    /**
     * Create a new appointment
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function create(Request $request)
    {
        
        $validator = Validator::make($request->all(), [
            'client_id' => 'required|exists:clients,id',
            'appointment_title' => 'required|string|max:255',
            'appointment_date' => 'required|date|after_or_equal:today',
            'appointment_time' => 'required|date_format:H:i',
            'no_of_persons' => 'required|integer|min:1|max:10',
            'notes' => 'nullable|string|max:1000',
            'attendees' => 'nullable|array',
            'attendees.*' => 'integer|exists:customer_members,id',
            'contact' => 'nullable|string|max:255',
        ]);
         
        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => $validator->errors()
            ], 422);
        }
       
        try {
            $appointment = Appointment::create([
                'client_id' => $request->client_id,
                'appointment_title' => $request->appointment_title,
                'appointment_date' => $request->appointment_date,
                'appointment_time' => $request->appointment_time,
                'no_of_persons' => $request->no_of_persons,
                'notes' => $request->notes,
                'attendees' => $request->attendees,
                'contact' => $request->contact,
                'status' => 'pending',
            ]);
          
            return response()->json([
                
                'success' => true,
                'message' => 'Appointment created successfully',
                'data' => [
                    'appointment' => [
                        'id' => $appointment->id,
                        'client_id' => $appointment->client_id,
                        'appointment_title' => $appointment->appointment_title,
                        'appointment_date' => $appointment->appointment_date->format('Y-m-d'),
                        'appointment_time' => $appointment->appointment_time,
                        'no_of_persons' => $appointment->no_of_persons,
                        'notes' => $appointment->notes,
                        'attendees' => $appointment->attendees,
                        'contact' => $appointment->contact,
                        'status' => $appointment->status,
                        'created_at' => $appointment->created_at->toISOString()
                    ]
                ]
            ], 200);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error creating appointment: ' . $e->getMessage()
            ], 500);
        }
    }

    /**
     * Get appointment history for a client
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function history(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'client_id' => 'nullable|exists:clients,id',
            'status' => 'nullable|in:pending,confirmed,completed,cancelled',
            'start_date' => 'nullable|date',
            'end_date' => 'nullable|date|after_or_equal:start_date',
            'limit' => 'nullable|integer|min:1|max:100',
            'offset' => 'nullable|integer|min:0'
        ]);

        if ($validator->fails()) {
            return response()->json([
                'success' => false,
                'message' => 'Validation failed',
                'errors' => $validator->errors()
            ], 422);
        }

        try {
            $query = Appointment::with(['client:id,name,email,phone']);

            // Filter by authenticated client if no client_id provided
            if (!$request->client_id) {
                $query->where('client_id', $request->user()->id);
            } else {
                $query->where('client_id', $request->client_id);
            }

            // Apply status filter
            if ($request->status) {
                $query->where('status', $request->status);
            }

            if ($request->start_date && $request->end_date) {
                $query->whereBetween('appointment_date', [$request->start_date, $request->end_date]);
            }

            // Order by appointment date and time
            $query->orderBy('appointment_date', 'desc')
                  ->orderBy('appointment_time', 'desc');

            // Apply pagination
            $limit = $request->limit ?? 20;
            $offset = $request->offset ?? 0;
            $appointments = $query->skip($offset)->take($limit)->get();

            $totalCount = $query->count();

            return response()->json([
                'success' => true,
                'message' => 'Appointment history retrieved successfully',
                'data' => [
                    'appointments' => $appointments->map(function($appointment) {
                        return [
                            'id' => $appointment->id,
                            'client_id' => $appointment->client_id,
                            'appointment_title' => $appointment->appointment_title,
                            'appointment_date' => $appointment->appointment_date->format('Y-m-d'),
                            'appointment_time' => $appointment->appointment_time,
                            'no_of_persons' => $appointment->no_of_persons,
                            'notes' => $appointment->notes,
                            'attendees' => $appointment->attendees,
                            'contact' => $appointment->contact,
                            'status' => $appointment->status,
                            'created_at' => $appointment->created_at->toISOString(),
                            'client' => $appointment->client
                        ];
                    }),
                    'pagination' => [
                        'total_count' => $totalCount,
                        'limit' => $limit,
                        'offset' => $offset,
                        'has_more' => ($offset + $limit) < $totalCount
                    ]
                ]
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error retrieving appointment history: ' . $e->getMessage()
            ], 500);
        }
    }
    
    /**
     * Get appointments by client_id for Flutter app
     *
     * @param int $clientId
     * @return \Illuminate\Http\JsonResponse
     */
    public function getAppointmentsByClient($clientId)
    {
        try {
            // Validate client ID
            if (!is_numeric($clientId) || $clientId <= 0) {
                return response()->json([
                    'success' => false,
                    'message' => 'Invalid client ID'
                ], 400);
            }

            // Check if client exists
            $client = \App\Models\Client::find($clientId);
            if (!$client) {
                return response()->json([
                    'success' => false,
                    'message' => 'Client not found'
                ], 404);
            }

            // Get appointments for the client
            $appointments = Appointment::where('client_id', $clientId)
                ->with(['client:id,name,email,phone'])
                ->orderBy('appointment_date', 'desc')
                ->orderBy('appointment_time', 'desc')
                ->get();

            // Format the response
            $formattedAppointments = $appointments->map(function($appointment) {
                // Get attendee names from customer_members table
                $attendeeNames = [];
                if ($appointment->attendees && is_array($appointment->attendees)) {
                    $attendeeNames = \App\Models\CustomerMember::whereIn('id', $appointment->attendees)
                        ->where('is_active', 1)
                        ->pluck('name')
                        ->toArray();
                }

                return [
                    'id' => $appointment->id,
                    'client_id' => $appointment->client_id,
                    'appointment_title' => $appointment->appointment_title,
                    'appointment_date' => $appointment->appointment_date->format('Y-m-d'),
                    'appointment_time' => $appointment->appointment_time,
                    'formatted_time' => $appointment->formatted_time,
                    'no_of_persons' => $appointment->no_of_persons,
                    'notes' => $appointment->notes,
                    'attendees' => $attendeeNames,
                    'attendees_ids' => $appointment->attendees, // Keep IDs for reference if needed
                    'contact' => $appointment->contact,
                    'status' => $appointment->status,
                    'created_at' => $appointment->created_at->toISOString(),
                    'updated_at' => $appointment->updated_at->toISOString(),
                    'client' => $appointment->client
                ];
            });

            return response()->json([
                'success' => true,
                'message' => 'Appointments retrieved successfully',
                'data' => [
                    'client' => [
                        'id' => $client->id,
                        'name' => $client->name,
                        'email' => $client->email,
                        'phone' => $client->phone
                    ],
                    'appointments' => $formattedAppointments,
                    'total_count' => $appointments->count(),
                    'status_counts' => [
                        'pending' => $appointments->where('status', 'pending')->count(),
                        'confirmed' => $appointments->where('status', 'confirmed')->count(),
                        'completed' => $appointments->where('status', 'completed')->count(),
                        'cancelled' => $appointments->where('status', 'cancelled')->count()
                    ]
                ]
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error retrieving appointments: ' . $e->getMessage()
            ], 500);
        }
    }

    /**
     * Get today's appointments by client_id API
     *
     * @param int $clientId
     * @return \Illuminate\Http\JsonResponse
     */
    public function getTodayAppointmentsByClient($clientId)
    {
        try {
            // Validate client ID
            if (!is_numeric($clientId) || $clientId <= 0) {
                return response()->json([
                    'success' => false,
                    'message' => 'Invalid client ID'
                ], 400);
            }

            // Check if client exists
            $client = \App\Models\Client::find($clientId);
            if (!$client) {
                return response()->json([
                    'success' => false,
                    'message' => 'Client not found'
                ], 404);
            }

            // Get today's appointments for the client
            $today = \Carbon\Carbon::today()->format('Y-m-d');
            $appointments = Appointment::where('client_id', $clientId)
                ->whereDate('appointment_date', $today)
                ->with(['client:id,name,email,phone'])
                ->orderBy('appointment_time', 'asc')
                ->get();

            // Format the response
            $formattedAppointments = $appointments->map(function($appointment) {
                // Get attendee names from customer_members table
                $attendeeNames = [];
                if ($appointment->attendees && is_array($appointment->attendees)) {
                    $attendeeNames = \App\Models\CustomerMember::whereIn('id', $appointment->attendees)
                        ->where('is_active', 1)
                        ->pluck('name')
                        ->toArray();
                }

                return [
                    'id' => $appointment->id,
                    'client_id' => $appointment->client_id,
                    'appointment_title' => $appointment->appointment_title,
                    'appointment_date' => $appointment->appointment_date->format('Y-m-d'),
                    'appointment_time' => $appointment->appointment_time,
                    'formatted_time' => $appointment->formatted_time,
                    'no_of_persons' => $appointment->no_of_persons,
                    'notes' => $appointment->notes,
                    'attendees' => $attendeeNames,
                    'attendees_ids' => $appointment->attendees, // Keep IDs for reference if needed
                    'contact' => $appointment->contact,
                    'status' => $appointment->status,
                    'created_at' => $appointment->created_at->toISOString(),
                    'updated_at' => $appointment->updated_at->toISOString(),
                    'client' => $appointment->client
                ];
            });

            return response()->json([
                'success' => true,
                'message' => 'Today\'s appointments retrieved successfully',
                'data' => [
                    'client' => [
                        'id' => $client->id,
                        'name' => $client->name,
                        'email' => $client->email,
                        'phone' => $client->phone
                    ],
                    'date' => $today,
                    'appointments' => $formattedAppointments,
                    'total_count' => $appointments->count(),
                    'status_counts' => [
                        'pending' => $appointments->where('status', 'pending')->count(),
                        'confirmed' => $appointments->where('status', 'confirmed')->count(),
                        'completed' => $appointments->where('status', 'completed')->count(),
                        'cancelled' => $appointments->where('status', 'cancelled')->count()
                    ]
                ]
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error retrieving today\'s appointments: ' . $e->getMessage()
            ], 500);
        }
    }

    /**
     * Get appointments by client_id and status for Flutter app
     *
     * @param int $clientId
     * @param string $status
     * @return \Illuminate\Http\JsonResponse
     */
    public function getAppointmentsByClientAndStatus($clientId, $status)
    {
        try {
            // Validate client ID
            if (!is_numeric($clientId) || $clientId <= 0) {
                return response()->json([
                    'success' => false,
                    'message' => 'Invalid client ID'
                ], 400);
            }

            // Validate status
            $validStatuses = ['pending', 'confirmed', 'completed', 'cancelled'];
            if (!in_array($status, $validStatuses)) {
                return response()->json([
                    'success' => false,
                    'message' => 'Invalid status. Must be one of: ' . implode(', ', $validStatuses)
                ], 400);
            }

            // Check if client exists
            $client = \App\Models\Client::find($clientId);
            if (!$client) {
                return response()->json([
                    'success' => false,
                    'message' => 'Client not found'
                ], 404);
            }

            // Get appointments for the client by status
            $appointments = Appointment::where('client_id', $clientId)
                ->where('status', $status)
                ->with(['client:id,name,email,phone'])
                ->orderBy('appointment_date', 'desc')
                ->orderBy('appointment_time', 'desc')
                ->get();

            // Format the response
            $formattedAppointments = $appointments->map(function($appointment) {
                // Get attendee names from customer_members table
                $attendeeNames = [];
                if ($appointment->attendees && is_array($appointment->attendees)) {
                    $attendeeNames = \App\Models\CustomerMember::whereIn('id', $appointment->attendees)
                        ->where('is_active', 1)
                        ->pluck('name')
                        ->toArray();
                }

                return [
                    'id' => $appointment->id,
                    'client_id' => $appointment->client_id,
                    'appointment_title' => $appointment->appointment_title,
                    'appointment_date' => $appointment->appointment_date->format('Y-m-d'),
                    'appointment_time' => $appointment->appointment_time,
                    'formatted_time' => $appointment->formatted_time,
                    'no_of_persons' => $appointment->no_of_persons,
                    'notes' => $appointment->notes,
                    'attendees' => $attendeeNames,
                    'attendees_ids' => $appointment->attendees, // Keep IDs for reference if needed
                    'contact' => $appointment->contact,
                    'status' => $appointment->status,
                    'created_at' => $appointment->created_at->toISOString(),
                    'updated_at' => $appointment->updated_at->toISOString(),
                    'client' => $appointment->client
                ];
            });

            return response()->json([
                'success' => true,
                'message' => ucfirst($status) . ' appointments retrieved successfully',
                'data' => [
                    'client' => [
                        'id' => $client->id,
                        'name' => $client->name,
                        'email' => $client->email,
                        'phone' => $client->phone
                    ],
                    'status' => $status,
                    'appointments' => $formattedAppointments,
                    'total_count' => $appointments->count()
                ]
            ]);

        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => 'Error retrieving appointments: ' . $e->getMessage()
            ], 500);
        }
    }
    
}