<?php

    namespace Modules\Webstatement\Jobs;

    use Exception;
    use Illuminate\Bus\Queueable;
    use Illuminate\Contracts\Queue\ShouldQueue;
    use Illuminate\Foundation\Bus\Dispatchable;
    use Illuminate\Queue\InteractsWithQueue;
    use Illuminate\Queue\SerializesModels;
    use Illuminate\Support\Facades\DB;
    use Illuminate\Support\Facades\Http;
    use Illuminate\Support\Facades\Log;
    use Modules\Webstatement\Models\Atmcard;

    class BiayaKartu implements ShouldQueue
    {
        use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

        /**
         * API dan database constants
         */
        private const API_BASE_PATH      = '/restgateway/services/IGATEToCoreBankingServices';
        private const API_INQUIRY_PATH   = '/InquiryBalanceService';
        private const DB_TABLE           = 'IST77.VW_CMS_VCARD';
        private const BATCH_SIZE         = 100;
        private const MAX_EXECUTION_TIME = 86400; // 24 jam dalam detik

        /**
         * Execute the job.
         */
        public function handle()
        : void
        {
            set_time_limit(self::MAX_EXECUTION_TIME);
            $this->syncAtmCards();
        }

        /**
         * Synchronize ATM cards data from Oracle database
         *
         * @return void
         */
        private function syncAtmCards()
        : void
        {
            try {
                $offset         = 0;
                $hasMoreRecords = true;

                while ($hasMoreRecords) {
                    $cards = $this->fetchCardBatch($offset);
                    $this->processCardBatch($cards);

                    $hasMoreRecords = count($cards) === self::BATCH_SIZE;
                    $offset         += self::BATCH_SIZE;
                }

                Log::info('Sinkronisasi kartu ATM berhasil diselesaikan');
            } catch (Exception $e) {
                Log::error('BiayaKartu: syncAtmCards: ' . $e->getMessage(), [
                    'file' => $e->getFile(),
                    'line' => $e->getLine()
                ]);
            }
        }

        /**
         * Fetch a batch of ATM cards from the database
         *
         * @param int $offset
         *
         * @return \Illuminate\Support\Collection
         */
        private function fetchCardBatch(int $offset)
        {
            return DB::connection('oracle')
                     ->table(self::DB_TABLE)
                     ->where('crsts', 1)
                     ->whereNotNull('ACCFLAG')
                     ->where('ACCFLAG', '>', 0)
                     ->skip($offset)
                     ->take(self::BATCH_SIZE)
                     ->get();
        }

        /**
         * Process a batch of ATM cards
         *
         * @param \Illuminate\Support\Collection $cards
         *
         * @return void
         */
        private function processCardBatch($cards)
        : void
        {
            foreach ($cards as $card) {
                try {
                    $existingCard = $this->getExistingCard($card->crdno);

                    // Perbarui data kartu dasar
                    $cardData = $this->getCardBaseData($card);

                    // Periksa jika perlu memperbarui branch dan currency
                    if ($this->needBranchAndCurrencyUpdate($existingCard)) {
                        $accountInfo = $this->getAccountInfo($card->accflag);
                        $this->updateBranchAndCurrency($card->crdno, $accountInfo);
                    } else {
                        Atmcard::updateOrCreate(['crdno' => $card->crdno], $cardData);
                    }
                } catch (Exception $e) {
                    Log::warning("Gagal memproses kartu {$card->crdno}: " . $e->getMessage());
                }
            }
        }

        /**
         * Get existing card from database if exists
         *
         * @param string $cardNumber
         *
         * @return Atmcard|null
         */
        private function getExistingCard(string $cardNumber)
        : ?Atmcard
        {
            return Atmcard::where('crdno', $cardNumber)->first();
        }

        /**
         * Get base data for card update
         *
         * @param object $card
         *
         * @return array
         */
        private function getCardBaseData(object $card)
        : array
        {
            return [
                'accflag'     => $card->accflag,
                'cracc1'      => $card->cracc1,
                'cracc2'      => $card->cracc2,
                'cracc3'      => $card->cracc3,
                'cracc4'      => $card->cracc4,
                'cracc5'      => $card->cracc5,
                'craccnam1'   => $card->craccnam1,
                'craccnam2'   => $card->craccnam2,
                'craccnam3'   => $card->craccnam3,
                'craccnam4'   => $card->craccnam4,
                'craccnam5'   => $card->craccnam5,
                'crsts'       => $card->crsts,
                'cttype'      => $card->cttype,
                'ctdesc'      => $card->ctdesc,
                'last_update' => $card->lastupdate,
            ];
        }

        /**
         * Check if branch and currency update is needed
         *
         * @param Atmcard|null $card
         *
         * @return bool
         */
        private function needBranchAndCurrencyUpdate(?Atmcard $card)
        : bool
        {
            // Jika kartu belum ada atau branch/currency belum terisi
            return $card === null || empty($card->branch) || empty($card->currency);
        }

        /**
         * Get account information from the API
         *
         * @param string $accountNumber
         *
         * @return array
         */
        private function getAccountInfo(string $accountNumber)
        : array
        {
            $url  = env('FIORANO_URL') . self::API_BASE_PATH;
            $path = self::API_INQUIRY_PATH;
            $data = [
                'accountNo' => $accountNumber
            ];

            $response = Http::post($url . $path, $data);

            return $response->json();
        }

        /**
         * Update branch and currency information for a card
         *
         * @param string $cardNumber
         * @param array  $accountInfo
         *
         * @return void
         */
        private function updateBranchAndCurrency(string $cardNumber, array $accountInfo)
        : void
        {
            $cardData = [
                'branch'   => $accountInfo['acctCompany'],
                'currency' => $accountInfo['acctCurrency'],
            ];

            Atmcard::where('crdno', $cardNumber)->update($cardData);

            Log::info("Berhasil memperbarui branch dan currency untuk kartu {$cardNumber}");
        }
    }