<?php

namespace App\Console\Commands;

use Carbon\Carbon;
use App\Models\Setting;
use App\Models\UserAbo;
use App\Services\MyLog;
use App\Services\Payment;
use App\Cron\UserMakeOrder;
use App\Services\AboHelper;
use App\Models\UserAboOrder;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Log;

class UserMakeAboOrder extends Command
{
    /**
     * ln -sfv /usr/bin/php73 /usr/bin/php
     *  php artisan business:store month year
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'user:make_abo_order';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Make Orders from Abos';

    private $timeStart;
    private $month;
    private $year;

    private $sendCreditMail = false;
    private $sendUpdateMail = false;

    /**
     * Create a new command instance.
     *
     * @return void
     */
    public function __construct()
    {
        parent::__construct();
    }

    /**
     * Execute the console command.
     *
     * @return int
     */
    public function handle()
    {
        $this->timeStart = microtime(true);
        \Log::channel('cron')->info('UserMakeAboOrder: Befehl gestartet');
        $this->info('RUN Command user:make_abo_order');

        try {
            $this->checkAbosToOrder();
            $executionTime = $this->getExecutionTime();
            \Log::channel('cron')->info("UserMakeAboOrder: Befehl erfolgreich abgeschlossen in {$executionTime}");
            $this->info("Befehl erfolgreich abgeschlossen in {$executionTime}");

            return 0;
        } catch (\Exception $e) {
            \Log::channel('cron')->error('UserMakeAboOrder: Fehler beim Ausführen des Befehls', [
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);
            $this->error('Fehler beim Ausführen des Befehls: ' . $e->getMessage());
            return 1;
        }
    }

    /**
     * Prüft alle Abos, die heute fällig sind und erstellt Bestellungen
     *
     * @return void
     */
    private function checkAbosToOrder()
    {
        $dateNow = Carbon::now()->format('Y-m-d');

        \Log::channel('abo_order')->info('UserMakeAboOrder: Suche nach fälligen Abos für Datum', ['date' => $dateNow]);

        $userAbos = UserAbo::where('next_date', '=', $dateNow)
            ->where('active', true)
            ->get();

        $count = $userAbos->count();
        \Log::channel('abo_order')->info("UserMakeAboOrder: {$count} fällige Abos gefunden");
        $this->info("Gefundene fällige Abos: {$count}");

        foreach ($userAbos as $userAbo) {
            \Log::channel('abo_order')->info('UserMakeAboOrder: Verarbeite Abo', [
                'abo_id' => $userAbo->id,
                'payone_userid' => $userAbo->payone_userid
            ]);

            $this->info("Verarbeite Abo: {$userAbo->id} (PayoneUserid: {$userAbo->payone_userid})");

            try {
                $shoppingOrder = $this->makeOrder($userAbo);

                if ($shoppingOrder) {
                    \Log::channel('abo_order')->info('UserMakeAboOrder: Bestellung erstellt', [
                        'abo_id' => $userAbo->id,
                        'order_id' => $shoppingOrder->id
                    ]);
                    $this->info("Bestellung erstellt: {$shoppingOrder->id}");
                } else {
                    \Log::channel('abo_order')->warning('UserMakeAboOrder: Keine Bestellung erstellt für Abo', ['abo_id' => $userAbo->id]);
                    $this->warn("Keine Bestellung erstellt für Abo: {$userAbo->id}");
                }
            } catch (\Exception $e) {
                \Log::channel('abo_order')->error('UserMakeAboOrder: Fehler bei der Verarbeitung des Abos', [
                    'abo_id' => $userAbo->id,
                    'error' => $e->getMessage(),
                    'trace' => $e->getTraceAsString()
                ]);
                $this->error("Fehler bei Abo {$userAbo->id}: " . $e->getMessage());
            }
        }
    }

    /**
     * Erstellt eine Bestellung für ein Abo
     *
     * @param UserAbo $userAbo
     * @return mixed
     */
    private function makeOrder($userAbo)
    {
        \Log::channel('abo_order')->info('UserMakeAboOrder: Starte Bestellungserstellung', ['abo_id' => $userAbo->id]);
        $this->info('Starte Bestellungserstellung für Abo: ' . $userAbo->id);

        $shoppingOrder = null;
        $userOrder = new UserMakeOrder($userAbo);

        try {
            if (!$userOrder->createShoppingUser()) {
                \Log::channel('abo_order')->error('UserMakeAboOrder: Konnte Shopping-User nicht erstellen', ['abo_id' => $userAbo->id]);
                $this->error("Konnte Shopping-User für Abo {$userAbo->id} nicht erstellen");
                return null;
            }

            $shoppingOrder = $userOrder->makeShoppingOrder();
            if (!$shoppingOrder) {
                \Log::channel('abo_order')->error('UserMakeAboOrder: Konnte Bestellung nicht erstellen', ['abo_id' => $userAbo->id]);
                $this->error("Konnte Bestellung für Abo {$userAbo->id} nicht erstellen");
                return null;
            }

            \Log::channel('abo_order')->info('UserMakeAboOrder: Bestellung erstellt, starte Zahlungsvorgang', [
                'abo_id' => $userAbo->id,
                'order_id' => $shoppingOrder->id
            ]);

            $response = $userOrder->makePayment();
            $this->info('makePayment response: ' . json_encode($response));

            if (!isset($response['status'])) {
                \Log::channel('abo_order')->error('UserMakeAboOrder: Ungültige Zahlungsantwort', [
                    'abo_id' => $userAbo->id,
                    'order_id' => $shoppingOrder->id,
                    'response' => $response
                ]);
                $this->error("Ungültige Zahlungsantwort für Abo {$userAbo->id}");
                return $shoppingOrder;
            }

            if ($response['status'] === 'APPROVED') {
                \Log::channel('abo_order')->info('UserMakeAboOrder: Zahlung erfolgreich', [
                    'abo_id' => $userAbo->id,
                    'order_id' => $shoppingOrder->id,
                    'response' => $response
                ]);
                $this->info("Zahlung erfolgreich für Abo {$userAbo->id}");
                $this->updateAbo($userAbo, $shoppingOrder, 1);
            } elseif ($response['status'] === 'ERROR') {
                \Log::channel('abo_order')->error('UserMakeAboOrder: Zahlungsfehler', [
                    'abo_id' => $userAbo->id,
                    'order_id' => $shoppingOrder->id,
                    'error' => $response
                ]);
                $this->error("Zahlungsfehler für Abo {$userAbo->id}");

                MyLog::writeLog(
                    'userabo',
                    'error',
                    'Error:3002 App\Console\Commands\UserMakeAboOrder::makeOrder / makePayment Error response',
                    $response
                );

                $this->updateAbo($userAbo, $shoppingOrder, 3);

                $shoppingPayment = $userOrder->getShoppingPayment();
                $data = [
                    'mode' => $shoppingPayment->mode,
                    'txaction' => 'error',
                    'send_link' => false,
                    'payment_error' => $response,
                ];

                Payment::paymentStatusSendMail($shoppingOrder, $shoppingPayment, $data);
            } else {
                \Log::channel('abo_order')->warning('UserMakeAboOrder: Unbekannter Zahlungsstatus', [
                    'abo_id' => $userAbo->id,
                    'order_id' => $shoppingOrder->id,
                    'status' => $response['status']
                ]);
                $this->warn("Unbekannter Zahlungsstatus für Abo {$userAbo->id}: {$response['status']}");
            }
        } catch (\Exception $e) {
            \Log::channel('abo_order')->error('UserMakeAboOrder: Ausnahme bei der Bestellungserstellung', [
                'abo_id' => $userAbo->id,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);
            $this->error("Ausnahme bei Abo {$userAbo->id}: " . $e->getMessage());
        }

        return $shoppingOrder;
    }

    /**
     * Aktualisiert das Abo nach einer Bestellung
     *
     * @param UserAbo $userAbo
     * @param mixed $shoppingOrder
     * @param int $status
     * @return void
     */
    private function updateAbo($userAbo, $shoppingOrder, $status = 1)
    {
        \Log::channel('abo_order')->info('UserMakeAboOrder: Aktualisiere Abo', [
            'abo_id' => $userAbo->id,
            'order_id' => $shoppingOrder->id,
            'status' => $status
        ]);

        $this->info("Aktualisiere Abo: {$userAbo->id} mit Status {$status}");

        $updateData = [
            'next_date' => AboHelper::setNextDate(now(), $userAbo->abo_interval),
            'last_date' => now(),
        ];

        if ($status !== 1) {
            $updateData['status'] = $status;
        }

        try {
            $userAbo->update($updateData);

            UserAboOrder::create([
                'user_abo_id' => $userAbo->id,
                'shopping_order_id' => $shoppingOrder->id,
                'status' => $status,
            ]);

            \Log::channel('abo_order')->info('UserMakeAboOrder: Abo erfolgreich aktualisiert', [
                'abo_id' => $userAbo->id,
                'next_date' => $updateData['next_date']
            ]);
        } catch (\Exception $e) {
            \Log::channel('abo_order')->error('UserMakeAboOrder: Fehler beim Aktualisieren des Abos', [
                'abo_id' => $userAbo->id,
                'error' => $e->getMessage()
            ]);
            $this->error("Fehler beim Aktualisieren des Abos {$userAbo->id}: " . $e->getMessage());
        }
    }

    /**
     * Berechnet die Ausführungszeit
     *
     * @return string
     */
    private function getExecutionTime()
    {
        $diff = microtime(true) - $this->timeStart;
        $sec = intval($diff);
        $micro = $diff - $sec;

        return $sec . ' Sekunden und ' . round($micro * 1000, 2) . ' ms';
    }
}