<?php

namespace App\Http\Controllers\V3\Dashboard;

use App\Facades\DataTable\DataTableFacade;
use App\Facades\File\FileFacade;
use App\Http\Controllers\Controller;
use App\Http\Requests\V3\Dashboard\UserManagement\GivePermissionRequest;
use App\Http\Requests\V3\Dashboard\UserManagement\GiveRoleRequest;
use App\Http\Requests\V3\Dashboard\UserManagement\StoreRequest;
use App\Http\Requests\V3\Dashboard\UserManagement\UpdateRequest;
use App\Http\Traits\ApiResponse;
use App\Models\City;
use App\Models\EdarateOstani;
use App\Models\EdarateShahri;
use App\Models\Province;
use App\Models\Role;
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

class UserManagementController extends Controller
{
    use ApiResponse;

    public function index(Request $request): JsonResponse
    {
        Auth::user()->addActivityComplete(1038);

        $data = DataTableFacade::run(
            User::query(),
            $request,
            allowedFilters: ['*'],
            allowedSortings: ['*'],
        );

        return $this->successResponse($data);
    }

    public function store(StoreRequest $request): jsonResponse
    {
        auth()->user()->addActivityComplete(1039);

        DB::transaction(function () use ($request) {
            $user = User::query()->create([
                'username' => $request->username,
                'national_code' => $request->national_code,
                'password' => Hash::make($request->password),
                'province_id' => $request->province_id ?: null,
                'province_fa' => ($request->province_id == 0) ? 'ستاد' : Province::find($request->province_id)->name_fa,
                'city_id' => $request->city_id ?: null,
                'city_fa' => ($request->city_id == 0) ? null : City::find($request->city_id)->name_fa,
                'edarate_ostani_id' => $request->edarate_ostani_id,
                'edarate_ostani_name' => EdarateOstani::query()->find($request->edarate_ostani_name),
                'edarate_shahri_id' => $request->edarate_shahri_id,
                'edarate_shahri_name' => EdarateShahri::query()->find($request->edarate_shahri_name),
                'first_name' => $request->first_name,
                'last_name' => $request->last_name,
                'position' => $request->position,
                'mobile' => $request->mobile,
                'degree' => $request->degree,
                'major' => $request->major,
            ]);
            $user->avatar = FileFacade::save($request->file('avatar'), "avatar/{$user->id}");
        });

        return $this->successResponse();
    }

    public function show(User $user)
    {
        $user = User::where('id', $user->id)->with(['roles', 'permissions'])->get();

        return $this->successResponse($user);
    }

    public function update(UpdateRequest $request, User $user): JsonResponse
    {
        auth()->user()->addActivityComplete(1040);
        DB::transaction(function () use ($request, $user) {

            $user->update([
                'username' => $request->username,
                'national_code' => $request->national_code,
                'province_id' => $request->province_id ?: null,
                'province_fa' => ($request->province_id == 0) ? 'ستاد' : Province::find($request->province_id)->name_fa,
                'city_id' => $request->city_id ?: null,
                'city_fa' => ($request->city_id == 0) ? null : City::find($request->city_id)->name_fa,
                'edarate_ostani_id' => $request->edarate_ostani_id,
                'edarate_ostani_name' => EdarateOstani::query()->find($request->edarate_ostani_name),
                'edarate_shahri_id' => $request->edarate_shahri_id,
                'edarate_shahri_name' => EdarateShahri::query()->find($request->edarate_shahri_name),
                'first_name' => $request->first_name,
                'last_name' => $request->last_name,
                'position' => $request->position,
                'mobile' => $request->mobile,
                'degree' => $request->degree,
                'major' => $request->major,
            ]);

            if ($request->has('avatar')) {
                FileFacade::delete($user->avatar, true);
                $user['avatar'] = FileFacade::save($request->file('avatar'), "avatar/{$user->id}/");
            }

            if (! is_null($request->password)) {
                $user->password = Hash::make($request->password);
            }

            if (! is_null($request->permissions)) {
                $user->syncPermissions(explode(',', $request->permissions));
            }

            if ($request->filled('roles')) {
                $user->syncRoles($request->roles);
            }

            $user->save();
        });

        return $this->successResponse();
    }

    public function destroy(User $user)
    {
        $user->delete();

        return $this->successResponse();
    }

    public function givePermissionsTo(GivePermissionRequest $request, User $user): JsonResponse
    {

        $user->givePermissionTo($request->permissions);

        return $this->successResponse($user->load('permissions'));
    }

    public function givePermissionsToRole(GivePermissionRequest $request, Role $role): JsonResponse
    {
        $permissionId = $request->permissions;
        $role->syncPermissions($permissionId);

        return $this->successResponse($role->load('permissions'));
    }

    public function giveRolesToUser(GiveRoleRequest $request, User $user): JsonResponse
    {
        $roles = $request->roles;

        $user->assignRole($roles);

        return $this->successResponse($user->load('roles'));
    }

    public function getUserPermissions(): JsonResponse
    {
        $userPermissions = Auth::user()->getUserPermissions();

        return $this->successResponse($userPermissions);
    }

    public function activityReport()
    {
        return view('version2.dashboard_pages.user_management.activity_report');
    }

    public function userActivityLogs()
    {
        return response()->json([
            'status' => 'succeed',
            'message' => '',
            'data' => auth()->user()->activityLogs,
        ], 200);
    }

    public function changeConfirmedStatus(Request $request)
    {
        $request->validate([
            'user_ids' => 'required|regex:/^(\d+)(,\d+)*$/',
            'confirm' => 'required|in:0,1',
        ]);

        $user_ids = explode(',', $request->user_ids);

        User::whereIn('id', $user_ids)->update([
            'confirmed' => $request->confirm,
        ]);

        return $this->successResponse();

    }

    public function changePassword(User $user, Request $request)
    {
        $validData = $request->validate([
            'password' => 'required|string|min:8|confirmed',
        ]);
        $user->password = Hash::make($request->password);
        $user->save();

        return $this->successResponse();
    }

    public function getUserSummaryReport(Request $request, User $user)
    {
        $request->fromDate = $request->fromDate ? $request->fromDate.' 00:00:00' : Carbon::now()->subDays(30)->format('Y-m-d 00:00:00');
        $request->toDate = $request->toDate ? $request->toDate.' 23:59:59' : Carbon::now()->format('Y-m-d 23:59:59');
        $data = [];

        $ids_list = '';
        $temp_sql_for_activity_time = "
        SELECT sum(majmoe) AS activity FROM (SELECT *,
        COUNT(cnt) AS majmoe
        FROM (
                SELECT *,
                    COUNT(*) AS cnt
                FROM (
                        SELECT YEAR (created_at) AS yy,
                            MONTH (created_at) AS mm,
                            DAY (created_at) AS dd,
                            HOUR (created_at) AS hh,
                            user_id
                        FROM user_activity_logs
                        WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$user->id.')
                    ) user_activity_distinct
                GROUP BY yy,
                    mm,
                    dd,
                    hh,
                    user_id
            ) user_activity_by_hour_and_
        GROUP BY user_id) AS calculated_table;';

        $temp_sql_for_activity_list = "
                SELECT *,
                    COUNT(*) AS cnt
                FROM (
                        SELECT 
                            description,
                            log_unique_code
                        FROM user_activity_logs
                        WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$user->id.')
                    ) user_activity_distinct
                GROUP BY
                    log_unique_code
                ORDER BY  cnt desc';

        $number_of_active_days = "
                SELECT COUNT(*) AS cnt
                FROM (
                        SELECT mm,dd
                        FROM user_activity_logs
                        WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$user->id.')
                        GROUP BY
                    mm,dd
                    ) active_days
                ORDER BY  cnt desc';

        $number_of_activities = "
        SELECT COUNT(*) AS cnt
                FROM user_activity_logs
                WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$user->id.')
        ORDER BY  cnt desc';

        $number_of_active_days = (DB::select($number_of_active_days)[0]->cnt ? DB::select($number_of_active_days)[0]->cnt : -1);
        $activity_time = DB::select($temp_sql_for_activity_time)[0]->activity;
        $number_of_activities = DB::select($number_of_activities)[0]->cnt;
        $data = [
            'number_of_active_days' => $number_of_active_days,

            'activity_time' => $user->id ? $activity_time : null,
            'average_activity_time' => round(($user->id ? $activity_time : 0) / $number_of_active_days, 2),
            'number_of_activities' => $number_of_activities,
            'average_activity_number' => round(($user->id ? $number_of_activities : 0) / $number_of_active_days, 2),

            'activity_list' => $user->id ? DB::select($temp_sql_for_activity_list) : null,
            'last_login' => $user->last_login,
        ];

        return $data;
    }

    public function printGroup(User $user, Request $request)
    {
        $request->fromDate = $request->fromDate ? $request->fromDate.' 00:00:00' : Carbon::now()->format('Y-m-d 00:00:00');
        $request->toDate = $request->toDate ? $request->toDate.' 23:59:59' : Carbon::now()->format('Y-m-d 23:59:59');

        $data = [];

        $ids_list = '';
        // $users = $role->users()->select("*")->get()->toArray();
        // foreach ($user as $index => $item) {
        $user_activity_quantity_temp[$user->id] = [
            'majmoe' => 0,
            'name' => $user->first_name ? $user->first_name.' '.$user->last_name.' ('.$user->username.')' : $user->name.' ('.$user->username.')',
        ];

        $user_activity_time_temp[$user->id] = [
            'majmoe' => 0,
            'name' => $user->first_name ? $user->first_name.' '.$user->last_name.' ('.$user->username.')' : $user->name.'('.$user->username.')',
        ];

        $user_activity_top_5_temp[$user->id] = [
            'activity_list' => [],
            'name' => $user->first_name ? $user->first_name.' '.$user->last_name.' ('.$user->username.')' : $user->name.'('.$user->username.')',
        ];

        // if (!$index) {
        $ids_list = $user->id;
        // } else {
        // $ids_list .= ",".$item['id'];
        // }
        // }
        $total_activity_time_sql = "
            SELECT sum(majmoe) AS activity FROM (SELECT *,
            COUNT(quantity) AS majmoe
            FROM (
                    SELECT user_id,
                        COUNT(*) AS quantity
                    
                            FROM user_activity_logs
                            WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
                        
                    GROUP BY yy,
                        mm,
                        dd,
                        hh,
                        user_id
                ) user_activity_by_hour_and_
            GROUP BY user_id) AS calculated_table;';

        $quantitative_activity_chart_sql = "
            SELECT created_at,
                COUNT(*) AS quantity
            
                        FROM user_activity_logs
                    WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
            GROUP BY 
                yy,
                mm,
                dd ;';

        $hourly_activity_chart_sql = "
            SELECT 
                COUNT(quantity) AS majmoe
            FROM (
                    SELECT yy,
                    mm,
                    dd,
                    hh,
                        COUNT(*) AS quantity
                            FROM user_activity_logs
                            WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
                    GROUP BY yy,
                        mm,
                        dd,
                        hh,
                        user_id
                ) user_activity_by_hour_and_
            GROUP BY 
                yy,
                mm,
                dd;';

        $total_activity_quantity_sql = "
            SELECT COUNT(*) AS total_activity_quantity
            FROM user_activity_logs
            WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
            ';

        $top_10_activity_list_sql = "
                    SELECT *,
                        COUNT(*) AS quantity
                    FROM (
                            SELECT 
                                description,
                                log_unique_code
                            FROM user_activity_logs
                            WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
                        ) user_activity_distinct
                    GROUP BY
                        log_unique_code
                    ORDER BY  quantity desc
                    LIMIT 10';

        $user_activity_quantity_sql = "
            SELECT *,
                COUNT(*) AS quantity
            FROM (
                    SELECT 
                        user_id,
                        user_first_name,
                        user_last_name,
                        user_name,
                        username
                    FROM user_activity_logs
                    WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
                ) user_activity_distinct
            GROUP BY user_id
            ORDER BY  quantity desc';

        $active_user_count_sql = "
            SELECT  COUNT(*) AS active_user_count
            FROM(
                SELECT 
                    user_id
                FROM user_activity_logs
                WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
                GROUP BY user_id
            ) grpuped_by_user_id';

        $user_activity_time_sql = "
        select 
            *,
            COUNT(quantity) AS majmoe
        FROM (
                SELECT
                    user_first_name,
                    user_last_name,
                    user_name,
                    username,
                    user_id,
                    COUNT(*) AS quantity
                        FROM user_activity_logs
                        WHERE created_at between '{$request->fromDate}' and '{$request->toDate}' and user_id IN(".$ids_list.')
                GROUP BY yy,
                    mm,
                    dd,
                    hh,
                    user_id
            ) user_activity_by_hour_and_ 
            GROUP BY user_id
            ORDER BY majmoe desc;';

        foreach (DB::select($user_activity_quantity_sql) as $key => $value) {
            $user_activity_quantity_temp[$value->user_id] = [
                'majmoe' => $value->quantity ?? 0,
                'name' => $value->user_first_name ? $value->user_first_name.' '.$value->user_last_name.' ('.$value->username.')' : $value->user_name.' ('.$value->username.')',
            ];
        }

        foreach (DB::select($user_activity_time_sql) as $key => $value) {
            $user_activity_time_temp[$value->user_id] = [
                'majmoe' => $value->majmoe ?? 0,
                'name' => $value->user_first_name ? $value->user_first_name.' '.$value->user_last_name.' ('.$value->username.')' : $value->user_name.' ('.$value->username.')',
            ];
        }

        foreach ($user_activity_top_5_temp as $key => $value) {
            $user_activity_top_5_temp_sql = "
                SELECT
                    description,
                    COUNT(*) AS quantity
                FROM user_activity_logs
                WHERE user_id = {$key} AND created_at between '{$request->fromDate}' and '{$request->toDate}'
                GROUP BY log_unique_code
                ORDER BY quantity DESC
                LIMIT 5
            ";

            $activity_list = DB::select($user_activity_top_5_temp_sql);
            $sum = 0;
            foreach ($activity_list as $index => $item) {
                $sum += (int) $item->quantity;
            }
            $user_activity_top_5_temp[$key] = [
                'sum' => $sum,
                'name' => $value['name'],
                'activity_list' => $activity_list,
            ];
        }
        arsort($user_activity_top_5_temp);
        arsort($user_activity_time_temp);
        arsort($user_activity_quantity_temp);
        $data = [
            'fromDate' => $request->fromDate ? $request->fromDate : null,
            'toDate' => $request->toDate ? $request->toDate : null,
            'user_activity_time' => $ids_list ? $user_activity_time_temp : null,
            'hourly_activity_chart' => $ids_list ? DB::select($hourly_activity_chart_sql) : null,
            'quantitative_activity_chart' => $ids_list ? DB::select($quantitative_activity_chart_sql) : null,
            'total_activity_quantity' => $ids_list ? DB::select($total_activity_quantity_sql)[0]->total_activity_quantity : null,
            'total_activity_time' => $ids_list ? DB::select($total_activity_time_sql)[0]->activity : null,
            'top_10_activity_list' => $ids_list ? DB::select($top_10_activity_list_sql) : null,
            'user_activity_quantity' => $ids_list ? $user_activity_quantity_temp : null,
            'group_name' => $user->first_name.' '.$user->last_name,
            'average' => round(($ids_list ? DB::select($total_activity_time_sql)[0]->activity : 0) / 1, 2),
            'user_activity_top_5_temp' => $user_activity_top_5_temp,
            'total_user_count' => 1,
            'active_user_count' => $ids_list ? DB::select($active_user_count_sql)[0]->active_user_count : null,
            'group_id' => $user->id,
        ];

        return View('word.user-activity-individual', compact('data'));
    }

    public function userPermission($id)
    {
        $user = User::find($id);

        return response()->json([
            'message' => 'success',
            'data' => $user->permissions,
        ]);
    }

    public function assignPermission(Request $request, User $user)
    {
        if (auth()->user()) {
            auth()->user()->addActivityComplete(1042);
        }
        $permissions = explode(',', $request->permissions);
        if (! $permissions == null) {
            $user->syncPermissions($permissions);
        }

        return response()->json([
            'message' => 'status',
            'data' => User::where('id', $user->id)->with(['permissions'])->get(),
        ]);
    }

    public function changeUserEnabeld(User $user)
    {
        if (Auth::user()->checkUserHasPermission('full-user-management')) {
            $user->enabled = ! $user->enabled;

            return $this->successResponse($user);
        } elseif (Auth::user()->checkUserHasPermission('limited-user-management') && Auth::user()->province_id == $user->province_id) {
            $user->enabled = ! $user->enabled;

            return $this->successResponse();
        } else {
            return response()->json([
                'message' => 'Forbidden',
            ], 403);
        }
    }
}