<?php

namespace App\Http\Controllers;

use App\Http\Requests\UpdateInfoUserRequest;
use App\InputValue;
use Illuminate\Http\Request;
use App\Http\Requests\StoreUserRequest;
use App\MedicalCenter;
use App\User;
use App\Message;
use Illuminate\Support\Facades\DB;
use Packages\Messaging\src\Facades\MessageResponse;

class UserController extends Controller
{
    public function index( Request $request )
    {
        $user = auth( 'api' )->user();

        if ( $user->hasRole( 'User' ) or $user->hasRole( 'Supervisor' ) ) {
            $medical_center_id = $user->medical_center_id;
        } elseif ( $request->has( 'medical_center_id' ) && $request->medical_center_id ) {
            $medical_center_id = $request->medical_center_id;
        } else {
            $medical_center_id = null;
        }

        $Users = User::when( $request->has( 'name' ) && $request->name , function ( $query ) use ( $request ) {
            $query->where( 'name' , 'LIKE' , '%' . $request->name . '%' );
        } )
            ->when( ( $request->has( 'fromPicker' ) && $request->fromPicker ) || ( $request->has( 'upToPicker' ) && $request->upToPicker ) , function ( $query ) use ( $request ) {
                $from = ( $request->fromPicker ) ? date( $request->fromPicker . ' 00:00:00' ) : date( '2010-01-01' . ' 00:00:00' );
                $upTo = ( $request->upToPicker ) ? date( $request->upToPicker . ' 23:59:59' ) : date( 'Y-m-d' . ' 23:59:59' );
                return $query->whereBetween( 'created_at' , [ $from , $upTo ] );
            } )
            ->when( $request->has( 'cell_number' ) && $request->cell_number , function ( $query ) use ( $request ) {
                $query->where( 'cell_number' , 'LIKE' , '%' . $request->cell_number . '%' );
            } )
            ->when( $request->has( 'role' ) && $request->role , function ( $query ) use ( $request ) {
                $query->role( $request->role );
            } )
            ->when( $medical_center_id , function ( $query ) use ( $medical_center_id ) {
                $query->where( 'medical_center_id' , $medical_center_id );
            } )
            ->with( [ 'medical_center' , 'roles' ] )->paginate( 10 );

        return MessageResponse::data( $Users );
    }

    public function store( StoreUserRequest $request )
    {
        if ( auth( 'api' )->user()->cant( 'store' , User::class ) ) {
            return MessageResponse::error( trans( 'messages.failed' ) );
        }
        $UserData = [
            'name' => $request->name ,
            'cell_number' => $request->cell_number ,
            'medical_center_id' => $request->medical_center_id ,
            'status' => 'Suspended' ,
            'verified' => "Verified" ,
            'password' => bcrypt( $request->password ) ,
        ];
        User::create( $UserData );
        return MessageResponse::success( trans( 'messages.success' ) );
    }

    public function edit( User $User )
    {
        return MessageResponse::data( $User );
    }

    public function update( StoreUserRequest $request , User $User )
    {
        if ( auth( 'api' )->user()->cant( 'update' , $User ) ) {
            return MessageResponse::error( trans( 'messages.failed' ) );
        }
        $UserData = [
            'name' => $request->name ,
            'cell_number' => $request->cell_number ,
            'medical_center_id' => $request->medical_center_id ,
            'verified' => "Verified" ,
            'password' => bcrypt( $request->password ) ,
        ];
        $User->update( $UserData );
        return MessageResponse::success( trans( 'messages.success' ) );
    }

    public function destroy( User $User )
    {
        if ( auth( 'api' )->user()->cant( 'delete' , $User ) ) {
            return MessageResponse::error( trans( 'messages.access_denied' ) );
        }
        try {
            DB::beginTransaction();

            // delete test_results
            foreach ( $User->test_results as $test_result ) {
                if ( count( $test_result->input_values ) ) {
                    InputValue::where( 'test_result_id' , $test_result->id )->get()->each->delete();
                }
                $test_result->delete();
            }

            // delete test_types
            foreach ( $User->test_types as $test_type ) {
                $UniqueID = substr( base_convert( sha1( uniqid( mt_rand() ) ) , 16 , 36 ) , 0 , 10 );
                $test_type->unique_code = $test_type->unique_code . '--' . $UniqueID;
                $test_type->save();
                $test_type->delete();
            }

            // delete items
            foreach ( $User->items as $item ) {
                $item->transfersAll()->delete();
                $item->delete();
            }

            // delete packages
            foreach ( $User->packages as $package ) {
                if ( count( $package->items ) ) {
                    foreach ( $package->items as $item ) {
                        $item->update( [
                            "package_id" => null
                        ] );
                    }
                }
                if ( count( $package->labels ) ) {
                    $package->labels()->delete();
                }
                $package->transfersAll()->delete();
                $package->delete();
            }

            // delete labels
            foreach ( $User->labels as $label ) {
                if ( count( $label->cycles ) ) {
                    $label->cycles()->detach();
                }
                $label->delete();
            }

            // delete cycles
            foreach ( $User->cycles as $cycle ) {
                if ( count( $cycle->labels ) ) {
                    $cycle->labels()->detach();
                }
                $cycle->delete();
            }

            // delete user
            $User->delete();

            DB::commit();
            return MessageResponse::success(trans('messages.success'));
        }catch (\Exception $exception){
            DB::rollBack();
            return MessageResponse::error($exception->getMessage());
        }
    }

    public function getByMedicalCenter( MedicalCenter $MedicalCenter )
    {
        $user = auth( 'api' )->user();

        if ( auth( 'api' )->user()->cant( 'getByMedicalCenter' , $MedicalCenter ) ) {
            return MessageResponse::error( trans( 'messages.failed' ) );
        }
        if ($user->hasRole('Admin')){
            $MedicalCenter = MedicalCenter::with(['users' => function ($query) {
                $query->select('id', 'medical_center_id', 'name', 'cell_number', 'status')
                    ->whereDoesntHave('roles', function ($roleQuery) {
                        $roleQuery->where('name', 'Admin');
                    });
            }, 'users.roles'])->get();
        }else{
            $MedicalCenter = $MedicalCenter->load( [ 'users' => function ( $query ) use ( $user ) {
                if ( $user->hasRole( 'User' ) ) {
                    return $query->select( [ 'id' , 'medical_center_id' , 'name' , 'cell_number' , 'status' ] )->where( 'id' , $user->id );
                } else {
                    return $query->select( [ 'id' , 'medical_center_id' , 'name' , 'cell_number' , 'status' ] )
                        ->whereDoesntHave('roles', function ($roleQuery) {
                            $roleQuery->where('name', 'Admin');
                        });
                }
            } , 'users.roles' ] );
        }

        return MessageResponse::data( $MedicalCenter );
    }

    public function changeStatus( User $User )
    {
        if ( auth( 'api' )->user()->cant( 'changeStatus' , User::class ) ) {
            return MessageResponse::error( trans( 'messages.access_denied' ) );
        }
        if ( $User->status == 'Active' ) {
            $User->status = 'Suspended';
            $tokens = DB::table( 'oauth_access_tokens' )->where( 'user_id' , $User->id );
            foreach ( $tokens->get() as $token ) {
                DB::table( 'oauth_refresh_tokens' )->where( 'access_token_id' , $token->id )->delete();
            }
            $tokens->delete();
        } else {
            $User->status = 'Active';
        }
        $User->save();
        return MessageResponse::data( $User );
    }

    public function changeRole( User $User , Request $request )
    {
        if ( auth( 'api' )->user()->cant( 'changeRole' , User::class ) ) {
            return MessageResponse::error( trans( 'messages.access_denied' ) );
        }
        $User->syncRoles( $request->roles );
        return MessageResponse::data( $User );
    }

    public function updateInfo( UpdateInfoUserRequest $request )
    {
        auth( 'api' )->user()->update( $request->validated() );
        return MessageResponse::success( trans( 'messages.success' ) );
    }

    public function getInfo()
    {
        $user = auth( 'api' )->user();
        $user->load( 'medical_center' );
        return MessageResponse::data( [ 'user' => $user , 'roles' => auth( 'api' )->user()->getRoleNames() ] );
    }

    public function getMessages()
    {
        $User = auth( 'api' )->user();
        $SentMessages = Message::with( 'recipient_user' )->where( 'sender_user_id' , $User->id )->get();
        $ReceivedMessages = Message::with( 'sender_user' )->where( 'recipient_user_id' , $User->id )->get();
        return MessageResponse::data( [ 'ReceivedMessages' => $ReceivedMessages , 'SentMessages' => $SentMessages ] );
    }

    public function searchUser( Request $request )
    {
        $role = null;
        $medical_center_id = null;

        $User = auth( 'api' )->user();
        if ( $User->hasRole( 'Supervisor' ) || $User->hasRole( 'User' ) ) {
            $medical_center_id = $User->medical_center_id;
            if ( $User->hasRole( 'Supervisor' ) ) {
                $role = 'Admin';
            }
        }

        $users = User::where( 'id' , '<>' , $User->id )->select( 'id' , 'name' )->where( 'name' , 'LIKE' , '%' . $request->name . '%' )
            ->when( $medical_center_id , function ( $query ) use ( $medical_center_id ) {
                $query->where( 'medical_center_id' , $medical_center_id );
            } )
            ->when( $role , function ( $query ) use ( $role ) {
                $query->role( $role );
            } )
            ->get();
        return MessageResponse::data( $users );
    }
}