<?php

namespace App\Http\Controllers;

use App\Mail\ReminderEmail;
use App\Models\Reminder;
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Mail;
use Yajra\DataTables\Facades\DataTables;
use Validator;


class ReminderController extends Controller
{
    /**
     * Display a listing of the resource.
     * use App\Mail\ReminderEmail;

     */
    public function index(Request $request)
    {
        if ($request->ajax()) {
            $search_keyword = '';
            $status = 'all'; // all status
            $request_data = $request->all();

            if ($request->has('status_filter')) {
                $status = $request->status_filter;
                
                $main_query = Reminder::where('entity_id', auth()->user()->id); 
                $query = $main_query;

            }
            // avoid zero column as it's checkbox so we can't sort by it
            if ($request->has('order') && $request->order[0]['column'] != 0) {
                $sort_column_number = $request->order[0]['column'];
                $sort_column_dir = $request->order[0]['dir'];
                $sort_column_key = $request->columns[$sort_column_number]['data'];
            }
             
            if (!$authUserId = auth()->id()) {
                return redirect()->route('login');
            }
            $user = auth()->user();
            $main_query = Reminder::with('user', 'created_by_user')
            ->where('entity_type', Reminder::Lead)
            ->where('created_at', '>=', Carbon::now()->subDays(7))
            ->where(function ($query) use ($authUserId) {
                $query->where('user_id', $authUserId)
                      ->orWhere('reminder_to', $authUserId);
            })
            ->where(function ($query) use ($user) {
                $query->where('user_id', $user->id);
                if (!is_null($user->parent_id)) {
                    $query->orWhere('user_id', $user->parent_id);
                    $query->orWhereIn('user_id', function ($subQuery) use ($user) {
                        $subQuery->select('id')
                            ->from('users')
                            ->where('parent_id', $user->parent_id)
                            ->where('id', '!=', $user->id);
                    });
                }
            });
// $main_query = Reminder::query()
//     ->where(function ($query) use ($user) {
//         // 1. Logged-in admin's data
//         $query->where('user_id', $user->id);
//         // 2. Parent's data (if the logged-in admin has a parent)
//         if (!is_null($user->parent_id)) {
//             $query->orWhere('user_id', $user->parent_id);
            
//             // 3. Siblings' data (users with the same parent_id, excluding logged-in admin)
//             $query->orWhereIn('user_id', function ($subQuery) use ($user) {
//                 $subQuery->select('id')
//                 ->from('users')
//                 ->where('parent_id', $user->parent_id) // Same parent_id as logged-in admin
//                 ->where('id', '!=', $user->id);       // Exclude logged-in admin
//             });
//         }
//     });


            

            // $main_query = Reminder::query();
            $query = $main_query;

            if ($status != 'all' && $status != '') {
                $query = $query->where('status', $status);
            }
            if (!empty($sort_column_key)) {
                $query = $query->orderBy($sort_column_key, $sort_column_dir);
            } else {
                $query = $query->latest();
            }

            $data = $query->with('user')->get();
            $count_total = $main_query->count();
            $count_filter = $count_total;
            return DataTables::of($data)

                ->addColumn('reminder_to', function ($row) {
                    return $row->user->first_name . $row->user->last_name;
                })
                ->addColumn('created_by', function ($row) {
                    return $row->created_by_user->first_name . $row->created_by_user->last_name;
                })
                ->addColumn('entity_type', function ($row) {
                    return $row->entity_type;
                })
                // ->addColumn('entity_id', function ($row) {
                //     return $row->entity_id;
                // })
                ->addColumn('description', function ($row) {
                    return $row->description;
                })
                ->addColumn('reminder_date', function ($row) {
                    return formatDate($row->reminder_date, 'Y/m/d H:i:s');
                })
                ->addColumn('is_notified', function ($row) {
                    return isset($row->is_notified) && $row->is_notified == 1 ? 'yes' : 'no';
                })
                ->addColumn('email_notification', function ($row) {

                    return isset($row->email_notification) && $row->email_notification == 1 ? 'yes' : 'no';
                })

                ->editColumn('status', function ($row) {
                    $update_url = route('user.update.task.status', $row->id);
                    return setStatus($row, $update_url);
                })
                ->addColumn('action', function ($row) {

                    if ($row->is_admin !== 1) {

                        return view('users.reminder.partially.delete', compact('row'));
                    }
                })
                ->rawColumns(['action', 'status'])
                ->with([
                    "recordsTotal"    => $count_total,
                    "recordsFiltered" => $count_filter,
                ])
                ->make(true);
        }
        return view('users.reminder.index');
    }


    /**
     * Show the form for creating a new resource.
     */
    public function create(Request $request)
{
    $currentUser = auth()->user();

    // Handle AJAX request for entity data
    if ($request->ajax() && $request->has('entity_type')) {
        $entityType = $request->input('entity_type');

        // Validate the entity type
        if (!in_array($entityType, array_keys(Reminder::Entity))) {
            return response()->json(['success' => false, 'message' => 'Invalid entity type']);
        }

        // Dynamically get the model class
        $modelClass = '\\App\\Models\\' . ucfirst($entityType);
        if (!class_exists($modelClass)) {
            return response()->json(['success' => false, 'message' => 'Entity model not found']);
        }

        // Fetch entities related to the current user, their parent, and siblings
        $entities = $modelClass::query()
            ->where(function ($query) use ($currentUser) {
                $query->where('created_by', $currentUser->id) // Entities created by the current user
                    ->orWhere('created_by', $currentUser->parent_id); // Entities created by the parent

                // Fetch entities related to siblings
                if (!is_null($currentUser->parent_id)) {
                    $query->orWhereIn('created_by', User::where('parent_id', $currentUser->parent_id)->pluck('id'));
                }
            })
            ->get();

        return response()->json(['success' => true, 'entities' => $entities]);
    }

    // Fetch users related to the current user, their parent, and siblings
    $users = User::query()
    ->where('status', User::ACTIVE) // Only active users
        ->where(function ($query) use ($currentUser) {
            $query->where('id', $currentUser->id) // Current user
                ->orWhere('id', $currentUser->parent_id); // Parent user

            // Sibling users
            if (!is_null($currentUser->parent_id)) {
                $query->orWhere('parent_id', $currentUser->parent_id);
            }

            // Child users
            $query->orWhere('parent_id', $currentUser->id);
        })
        ->get();

    return view('users.reminder.create', compact('users'));
}


    /**
     * Store a newly created resource in storage.
     */
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'reminder_to' => 'required|exists:users,id',

        ]);


        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }

        $reminder = new Reminder();
        $currentUserId = getAdminId();
        $reminder ->created_by = auth()->id();
  
        $reminder->user_id = isset(auth()->user()->parent_id) ? auth()->user()->parent_id : auth()->id() ; 
        if (isset($reminder)) {
            $reminder->reminder_to = $request->reminder_to;
            $currentUserId =  getAdminId();
            $reminder->created_by = $currentUserId->created_by;
            $reminder->entity_type = $request->entity_type;
            $reminder->entity_id = $request->entity_id;
            $reminder->description = $request->description;
            $reminder->reminder_date = $request->reminder_date;

            $reminder->is_notified = $request->has('is_notified') ? 1 : 0;

            $reminder->email_notification = $request->has('email_notification') ? 1 : 0;
            $reminder->status = $request->has('is_active') ? 1 : 0;
            $reminder->save();


            return redirect()->route('reminder.index')->with('success', 'Reminder Add Successfully');
        } else {
            return back()->with('error', 'Reminder does not exist');
        }
    }

    /**
     * Display the specified resource.
     */
    public function show(string $id)
    {
        $reminder = Reminder::findorFail($id);
        return view('users.reminder.show', compact('reminder'));
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(string $id)
    {
        $reminder = Reminder::findOrFail($id);
        $users = User::all();
        return view('users.reminder.edit', compact('reminder', 'users'));
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(Request $request, string $id)
    {

        $validator = Validator::make($request->all(), [

            'reminder_to' => 'required|exists:users,id',

        ]);


        if ($validator->fails()) {
            return redirect()->back()->withErrors($validator)->withInput();
        }
        $reminder = Reminder::find($id);
        if (isset($reminder)) {
            $reminder->reminder_to = $request->reminder_to;
            $currentUserId =  getAdminId();
            $reminder->created_by = $currentUserId->created_by;
            $reminder->entity_type = $request->entity_type;
            $reminder->entity_id = $request->entity_id;
            $reminder->description = $request->description;
            $reminder->reminder_date = $request->reminder_date;
            $reminder->is_notified = $request->has('is_notified') ? 1 : 0;
            $reminder->email_notification = $request->has('email_notification') ? 1 : 0;
            $reminder->status = $request->has('is_active') ? 1 : 0;
            $reminder->save();

            // $user = User::find($request->reminder_to);
            // if ($reminder->email_notification == 1) {
            //     $user = User::find($request->reminder_to);
            //     if ($user) {
            //         // Prepare email content
            //         $emailBody = "Reminder Details:  \n" .
            //             "Description: {$reminder->description}\n" .
            //             "Reminder Date: {$reminder->reminder_date}\n";

            //         // Send the email
            //         Mail::to($user->email)->send(new ReminderEmail($emailBody));
            //     }
            // }
            return redirect()->route('reminder.index')->with('success', ' Reminder has been updated successfully');
        } else {
            return back()->with('error', 'Reminder does not exist');
        }
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(string $id)
    {
        $reminder = Reminder::find($id);
        if (isset($reminder)) {
            $reminder->delete();
            return redirect()->back()->with('success', 'Reminder has been deleted successfully.');
        } else {
            return back()->with('error', 'Reminder does not exist');
        }
    }

    public function updateReminderStatus(Request $request, $id)
    {
        if ($request->has('new_status')) {
            $reminder = Reminder::find($id);

            if ($reminder) {
                $reminder->status = $request->new_status;
                $reminder->save();
                return response()->json(['status' => 'success', 'message' => 'Reminder status updated successfully']);
            } else {
                return response()->json(['status' => 'error', 'message' => 'Reminder not found'], 404);
            }
        } else {
            return response()->json(['status' => 'error', 'message' => 'Missing status value'], 404);
        }
    }
}