<?php
namespace App\Http\Services;

use App\Classes\Polarity;
use App\Http\Services\UserCreditService;
use App\Models\PaymentRecord;
use App\Models\User;
use App\Models\UserCredit;
use Illuminate\Support\Str;
use Illuminate\Validation\ValidationException;
use Pylon\Exceptions\BadRequestException;
use Queriplex;
use Auth;
use App\Exports\BasicExcelExport;
use Maatwebsite\Excel\Facades\Excel;
use App\Classes\GCSFileUploader;
use Carbon\Carbon;

class PaymentRecordService
{	

	public function __construct(
		UserCreditService $userCreditService
	)
	{
		$this->userCreditService = $userCreditService;
	}

#################################### START IPAY88 CORE FUNCTIONS  #######################################

	public function readyPaymentRecord(User $user, Array $payload)
	{	
		$uniqueID = Str::orderedUuid(); // genereate VVVVVVVV-VVVV-XXXX-XXXX-XXXXXXXXXXXX (v: version from timestamp, x: random variant)
		$uniqueID_30L = substr($uniqueID->toString(), 0, 24).random_int(100000,999999);

		$paymentRecord = PaymentRecord::create([
			'unique_id' => $uniqueID_30L,
			'user_id' => $user->id,
			'type_id' => $payload['type_id'],
			'status_id' => Polarity::NEUTRAL,
			'remark' => $payload['remark'],
			'amount' => $payload['amount'],
			'request_meta' => [
				'currency' => $payload['currency'],
				'prodDesc' => $payload['prodDesc'],
				'userName' => $user->full_name,
				'userEmail' => $user->email,
				'userContact' => $user->mobile_num,
			],
			'response_meta' => [],
		]);

		return $paymentRecord;
	}

	public function paymentSuccessful(Array $request, $paymentRecord = null)
	{
		if(!$paymentRecord){
			$paymentRecord = PaymentRecord::where('unique_id',$request['RefNo'])->firstOrFail();
		}

		// check & prevent over process on same payment
		if($paymentRecord->status_id != Polarity::NEUTRAL){
			return null;
		}

    	$paymentRecord->record_id = $request['TransId'];
    	$paymentRecord->status_id = Polarity::POSITIVE;
    	$paymentRecord->response_meta['response_at'] = now();
    	$paymentRecord->save();

		switch ($paymentRecord->type_id) {
			case PaymentRecord::TYPE_CREDIT_TOP_UP:
				self::handleTopUpCredit($paymentRecord);
				break;
			
			default:
				break;
		}

		return $paymentRecord;
	}

	public function paymentFailed(Array $request, $paymentRecord = null)
	{   
		if(!$paymentRecord){
			$paymentRecord = PaymentRecord::where('unique_id',$request['RefNo'])->firstOrFail();
		}

		// check & prevent over process on same payment
		if($paymentRecord->status_id != Polarity::NEUTRAL){
			return null;
		}

		$paymentRecord->status_id = Polarity::NEGATIVE;
    	$paymentRecord->response_meta['errDesc'] = $request['ErrDesc'];
    	$paymentRecord->response_meta['response_at'] = now();
    	$paymentRecord->save();

		return $paymentRecord;
	}

	public function requery(Array $request)
	{	
		try {
			$paymentRecord = PaymentRecord::where('unique_id',$request['id'])
				->firstOr(Function(){
					throw ValidationException::withMessages([
						"id" => "The selected id is invalid.",
					]);
				});

			$requeryBuilder = $paymentRecord->toIPay88Requery();

			if($requeryBuilder->isSuccess())
			{
				$paymentRecord->status_id = Polarity::POSITIVE;
				$requery_msg = "Payment Success";
			}
			else if($requeryBuilder->isFailure() || $requeryBuilder->recordNotFound())
			{
				$paymentRecord->status_id = Polarity::NEGATIVE;
				$requery_msg = $requeryBuilder->getResultMessage();
			}
			$paymentRecord->response_meta['requery_result'] = $requery_msg;
			$paymentRecord->response_meta['last_requery_at'] = now();
			
			$paymentRecord->save();

			return $paymentRecord;
			
		} catch (\IPay88\Exceptions\DailyRequeryLimitException $e) {
			throw new BadRequestException($e->getMessage());
		}
	}

#################################### END IPAY88 CORE FUNCTIONS  #######################################

	public function listPaymentRecord(Array $request)
	{
        $paymentRecords = PaymentRecord::query();

        $paymentRecords = self::queriplex($paymentRecords, $request);

        $result = $paymentRecords->paginate($request['itemsPerPage'] ?? null);

        $result->load('user');

        return $result;
	}

	public function exportPaymentRecordList(Array $request)
	{
		$fileUploader = false;
		$user = Auth::user();
		$paymentRecords = PaymentRecord::query();

		$paymentRecords = self::queriplex($paymentRecords, $request);
		
		$result = $paymentRecords->orderBy("created_at","DESC")
			->get();

		if($result->isEmpty())
			return false;

		$result->load([
			'user'
		]);
		
		if($user->isSuperAdmin())
		{
			$data = $result->map(function($item) use($user)
			{

					return [
						'id' => $item->id,
						'user' => $item->user ? $item->user->full_name : '-',
						'user_email' => $item->user ? $item->user->email : '-',
						'user_mobile_num' => $item->user ? $item->user->mobile_num : '-',
						'amount (RM)' => $item->amount,
						'type' => $item->type,
						'status' => $item->status,
						'created_at' => $item->created_at,
					];
			});

			$export = new BasicExcelExport($data);
			$file_name = now()->format('Ymdhms')."-User-Payment-Record.xlsx";
			Excel::store($export, $file_name);
			$fileUploader = new GCSFileUploader($file_name);
			$fileUploader->setDirectory('reports/payment-records');
			$fileUploader->upload();
		}

		return $fileUploader;
	}


    public function queriplex($query, $request){

        $order_mode = ( $request['sortDesc'] ?? false )  ? 'DESC' : 'ASC';
        $search_by = $request['searchBy'] ?? null;

        $queriplex = Queriplex::make($query)
            ->withFilters($request, [
                'id' => 'id',
                'search' => ( fn($query, $value) => self::searchQuery($query,$value,$search_by) ),
				"date" => function($query, $value){
					$date_1 = new Carbon($value[0]);
					$date_2 = count($value) > 1 ? new Carbon($value[1]) : new Carbon($value[0]);

					if($date_1->gt($date_2))
					{
						$datetime_1 = $date_2->startOfDay();
						$datetime_2 = $date_1->endOfDay();
					}
					else
					{
						$datetime_1 = $date_1->startOfDay();
						$datetime_2 = $date_2->endOfDay();
					}
					\Debugbar::info($datetime_1, $datetime_2);

					$query->whereDate("created_at",'>=',$datetime_1)->whereDate("created_at",'<=',$datetime_2);
				},
            ])
            ->withSort($request['sortBy'] ?? null, [
                "id" => fn($query) => $query->orderBy('id', $order_mode),
                "created_at" => fn($query) => $query->orderBy('created_at', $order_mode),
            ]);

        return $queriplex->apply();
    }

    public function searchQuery($query, $value, $search_by){

        $common_searchable = [
            'id',
        ];          
        if(in_array($search_by,$common_searchable)){
            $query->search($search_by,$value);
        }
		else
		{
			if($search_by == "name"){
				$query->whereHas("user",function($q) use ($value){
					$q->search("full_name",$value);
				});
			}else if($search_by == "created_at")
			{
				$query->where('created_at', '>=', $value[0]);
				if(sizeof($value)>1)
					$query->where('created_at', '<=', $value[1]);
			}
		}

        return null;
    }

	public function readyTopUpCredit(User $user, Array $payload)
	{
		$paymentRecord = self::readyPaymentRecord($user, [
			'amount' => $payload['amount'],
			'remark' => $payload['remark'] ?? null,
			'currency' => "MYR",
			'prodDesc' => "Top Up Credit",
			'type_id' => PaymentRecord::TYPE_CREDIT_TOP_UP,
		]);

		return $paymentRecord;
	}

	public function handleTopUpCredit(PaymentRecord $paymentRecord)
	{
		$userCredit = $this->userCreditService->userCreditCreate([
			"user_id" => $paymentRecord->user_id,
			"type_id" => UserCredit::TOP_UP,
			"title" => "Top Up Credit",
			"amount" => $paymentRecord->amount,
			"meta" => [
				"paymentRecord" => $paymentRecord->id
			],
		]);

		return null;
	}
}