<?php

namespace App\Browser\Jobs\HellcaseBattles;

use App\Browser\Jobs\Hellcase\HellcaseJob;
use App\Models\HellcaseBattle;
use App\Models\Job;
use App\Models\JobRun;
use App\Notification\Notifications\JobDebugNotification;
use App\Notification\Providers\AllNotification;
use Exception;
use Facebook\WebDriver\WebDriver;
use Facebook\WebDriver\WebDriverBy;
use Illuminate\Contracts\Queue\ShouldBeUniqueUntilProcessing;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use Laravel\Dusk\Browser;

class HellcaseBattlesJob extends HellcaseJob implements ShouldBeUniqueUntilProcessing
{
    private Collection $jobInfos;
    private array $battlesToAdd = [];

    public function __construct()
    {
        Log::info("Constructing HellcaseBattlesJob");
        parent::__construct(3);
    }

    public function run(Browser $browser): ?JobRun
    {
        $this->jobInfos = Job::find($this->jobId)->jobInfosTable();
        Log::info("Running HellcaseBattlesJob");
        $this->jobRun = new JobRun([
            "job_id" => $this->jobId,
            "success" => false,
        ]);
        $this->jobRun->save();

        $browser->visit('https://hellcase.com');
        $browser->waitForText("CASES", 30, true);
        $this->removePopups($browser);
        sleep(5);
        $this->signin($browser);

        $this->saveInterestingBattles($browser);

        $this->sendFinishedBattles($browser);

        $this->createNewBattles();

        $this->jobRun->success = true;
        $this->jobRun->save();

        Log::info("HellcaseBattlesJob run ended");

        return $this->jobRun;
    }

    /**
     * Save current cases battles to database for later processing
     * @param \Laravel\Dusk\Browser $browser
     * @return void
     */
    private function saveInterestingBattles(Browser $browser)
    {
        $battleIndex = 0; // Index of the battle to get info from
        $running = true;
        while ($running) {
            $browser->visit('https://hellcase.com/casebattle');
            $browser->waitForText("CASES", 30, true);

            AllNotification::send(new JobDebugNotification($this->jobId, "I hate niggers"));

            // Sort by price
            try {
                $sortByPriceDiv = $browser->driver->findElement(WebDriverBy::xpath("//*[span[contains(text(), 'Value')]]"));
                $sortByPriceDiv->click();
            } catch (Exception $e) {
                AllNotification::send(new JobDebugNotification($this->jobId, "Failed to sort by price"));
                return;
            }

            sleep(5);

            $battles = $browser->driver->findElements(WebDriverBy::xpath("//*[contains(@class, 'casebattle-table__item')]"));
            $battle = $battles[$battleIndex];
            $battleIndex++;
            $browser->scrollIntoView(".casebattle-table__item:nth-child(" . max($battleIndex -1, 1) . ")");
            sleep(2);
            $battleValue = floatval(
                explode(
                    "\n",
                    $battle->findElement(WebDriverBy::xpath("./div/div[contains(@class, 'core-price')]"))->getDomProperty("innerText")
                )[1]
            );

            if ($battleValue < floatval($this->jobInfos->get("hellcase_battles_minimum_value"))) {
                $running = false;
                break;
            }

            $battleLinkButton = $battle->findElement(WebDriverBy::xpath('./div//button[text() = "watch"]'));
            $battleLinkButton->sendKeys("\n");
            sleep(3);
            $battleLink = $browser->driver->getCurrentURL();

            $this->battlesToAdd[$battleLink] = $battleValue;
        }
    }

    private function sendFinishedBattles(Browser $browser) {
        // foreach battle that we didn"t already planned to add with $this->battlesToAdd
        foreach (HellcaseBattle::all() as $battle) {
            dump($battle);
            if (!array_key_exists($battle->getUrl(), $this->battlesToAdd)) {
                dump("finished");
                $browser->visit($battle->getUrl());

                try {
                    $browser->waitForText("Started at");
                    // Send the battle
                    $this->sendBattle($browser, $battle);
                } catch (Exception $e) { // Battle is not finished or error (like battle cancelled)
                }

                $battle->delete();
            }
        }
    }

    private function sendBattle(Browser $browser, HellcaseBattle $battle) {
        AllNotification::send(new JobDebugNotification($this->jobId, "Battle sent" . $battle->getUrl()));
    }

    private function createNewBattles() {
        foreach ($this->battlesToAdd as $battleLink => $battleValue) {
            $battleLink = explode("/", $battleLink);
            HellcaseBattle::firstOrCreate([
                "battle_id" => $battleLink[count($battleLink) - 1],
                "value" => $battleValue,
            ]);
        }
    }
}