<?php

namespace Tests\Feature;

use App\Models\Device;
use App\Models\WalletAddress;
use App\Models\WalletMnemonic;
use App\Services\Chain\EthDriver;
use App\Services\Chain\TronDriver;
use App\Services\IngestService;
use App\Services\MnemonicAddressLinker;
use App\Services\Tokenview\TokenviewMonitorService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Http;
use Mockery;
use PHPUnit\Framework\Attributes\Test;
use Tests\TestCase;

class MnemonicAddressLinkTest extends TestCase
{
    use RefreshDatabase;

    private const MNEMONIC = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';

    private const TRON_0 = 'TUEZSdKsoDHQMeZwihtdoBiN46zxhGWYdH';

    private const ETH_0 = '0x9858effd232b4033e47d90003d41ec34ecaeda94';

    protected function setUp(): void
    {
        parent::setUp();

        config([
            'coruna.telegram.bot_token' => '',
            'coruna.telegram.owner_chat_id' => '',
        ]);

        $tokenview = Mockery::mock(TokenviewMonitorService::class);
        $tokenview->shouldReceive('syncMonitor')->andReturn(false);
        $tokenview->shouldReceive('shouldMonitor')->andReturn(false);
        $this->app->instance(TokenviewMonitorService::class, $tokenview);

        Http::fake();
    }

    private function makeDevice(string $id = 'dev-link-1'): Device
    {
        return Device::query()->create([
            'device_id' => $id,
            'ios_version' => '18.0',
            'device_model' => 'iPhone',
        ]);
    }

    private function storeMnemonic(Device $device, string $source = 'imToken'): WalletMnemonic
    {
        $row = new WalletMnemonic([
            'device_id' => $device->id,
            'source' => $source,
        ]);
        $row->mnemonic = self::MNEMONIC;
        $row->save();

        return $row;
    }

    #[Test]
    public function linking_address_after_mnemonic_sets_fk(): void
    {
        $device = $this->makeDevice();
        $mnemonic = $this->storeMnemonic($device);

        $addr = WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => self::TRON_0,
            'chain_type' => 'TRON',
            'source' => 'MetaMask',
            'monitor' => 0,
        ]);

        $linked = app(MnemonicAddressLinker::class)->linkAddress($addr);

        $this->assertTrue($linked);
        $addr->refresh();
        $this->assertSame($mnemonic->id, $addr->mnemonic_id);
        $this->assertSame(0, $addr->derive_index);
    }

    #[Test]
    public function linking_mnemonic_after_addresses_backfills(): void
    {
        $device = $this->makeDevice('dev-link-2');

        WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => self::TRON_0,
            'chain_type' => 'TRON',
            'source' => 'TronLink',
            'monitor' => 0,
        ]);
        WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => self::ETH_0,
            'chain_type' => 'ETHEREUM',
            'source' => 'MetaMask',
            'monitor' => 0,
        ]);

        $mnemonic = $this->storeMnemonic($device, 'imToken');
        $count = app(MnemonicAddressLinker::class)->linkMnemonicToDeviceAddresses($mnemonic);

        $this->assertSame(2, $count);
        $this->assertSame(2, WalletAddress::query()->where('mnemonic_id', $mnemonic->id)->count());
        $this->assertSame(
            [0, 0],
            WalletAddress::query()->where('mnemonic_id', $mnemonic->id)->orderBy('id')->pluck('derive_index')->all()
        );
    }

    #[Test]
    public function mnemonic_link_only_derives_chains_present_on_device(): void
    {
        $device = $this->makeDevice('dev-link-3');
        $tronDriver = new TronDriver;
        $ethDriver = new EthDriver;

        // Only TRON + ETH on device — BTC must not be required for a match.
        WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => $tronDriver->deriveAddress(self::MNEMONIC, 1),
            'chain_type' => 'TRON',
            'source' => 'a',
            'monitor' => 0,
        ]);
        WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => $ethDriver->deriveAddress(self::MNEMONIC, 2),
            'chain_type' => 'ETH',
            'source' => 'b',
            'monitor' => 0,
        ]);

        $mnemonic = $this->storeMnemonic($device);
        $count = app(MnemonicAddressLinker::class)->linkMnemonicToDeviceAddresses($mnemonic);

        $this->assertSame(2, $count);
        $rows = WalletAddress::query()->where('device_id', $device->id)->orderBy('id')->get();
        $this->assertSame(1, $rows[0]->derive_index);
        $this->assertSame(2, $rows[1]->derive_index);
        $this->assertSame($mnemonic->id, $rows[0]->mnemonic_id);
        $this->assertSame($mnemonic->id, $rows[1]->mnemonic_id);
    }

    #[Test]
    public function derive_index_nine_is_linked(): void
    {
        $device = $this->makeDevice('dev-link-4a');
        $tron = (new TronDriver)->deriveAddress(self::MNEMONIC, 9);

        $addr = WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => $tron,
            'chain_type' => 'TRON',
            'source' => 'imToken',
            'monitor' => 0,
        ]);
        $mnemonic = $this->storeMnemonic($device);

        $this->assertTrue(app(MnemonicAddressLinker::class)->linkAddress($addr));
        $addr->refresh();
        $this->assertSame($mnemonic->id, $addr->mnemonic_id);
        $this->assertSame(9, $addr->derive_index);
    }

    #[Test]
    public function derive_index_beyond_nine_is_not_linked(): void
    {
        $device = $this->makeDevice('dev-link-4');
        $tron = (new TronDriver)->deriveAddress(self::MNEMONIC, 10);

        $addr = WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => $tron,
            'chain_type' => 'TRON',
            'source' => 'imToken',
            'monitor' => 0,
        ]);
        $mnemonic = $this->storeMnemonic($device);

        $this->assertFalse(app(MnemonicAddressLinker::class)->linkAddress($addr));
        $this->assertSame(0, app(MnemonicAddressLinker::class)->linkMnemonicToDeviceAddresses($mnemonic));
        $addr->refresh();
        $this->assertNull($addr->mnemonic_id);
        $this->assertNull($addr->derive_index);
    }

    #[Test]
    public function unmatched_address_stays_unlinked(): void
    {
        $device = $this->makeDevice('dev-link-5');
        $this->storeMnemonic($device);

        $addr = WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => 'TXYZunmatched111111111111111111111',
            'chain_type' => 'TRON',
            'source' => 'imToken',
            'monitor' => 0,
        ]);

        $this->assertFalse(app(MnemonicAddressLinker::class)->linkAddress($addr));
        $addr->refresh();
        $this->assertNull($addr->mnemonic_id);
    }

    #[Test]
    public function ingest_address_after_mnemonic_links_via_ingest(): void
    {
        $device = $this->makeDevice('dev-link-ingest-1');
        app(IngestService::class)->ingestMnemonic($device, [
            'a' => 'b',
            'result' => self::MNEMONIC,
        ]);

        Http::fake([
            '*' => Http::response(['jsonrpc' => '2.0', 'id' => 1, 'result' => '0x0'], 200),
        ]);

        app(IngestService::class)->ingestAddresses($device, [
            'a' => 'a',
            'ba' => [
                self::ETH_0 => [
                    ['balance' => '0', 'chainType' => 'ETHEREUM', 'symbol' => 'ETH', 'decimal' => 18],
                ],
            ],
        ]);

        $addr = WalletAddress::query()->where('address', self::ETH_0)->first();
        $this->assertNotNull($addr);
        $this->assertNotNull($addr->mnemonic_id);
        $this->assertSame(0, $addr->derive_index);
        $this->assertSame(
            WalletMnemonic::query()->where('device_id', $device->id)->value('id'),
            $addr->mnemonic_id
        );
    }

    #[Test]
    public function new_eth_address_with_bsc_funds_also_creates_bsc_row(): void
    {
        config([
            'coruna.bsc.rpc_url' => 'https://bsc.example',
            'coruna.bsc.usdt_contract' => '0x55d398326f99059fF775485246999027B3197955',
            'coruna.bsc.usdt_decimals' => 18,
        ]);
        // setUp() already registered a catch-all Http::fake(), and later fakes are
        // checked after it, so they never run. Replace the client first.
        Http::swap(new \Illuminate\Http\Client\Factory);
        Http::fake([
            'https://bsc.example' => Http::sequence()
                ->push(['jsonrpc' => '2.0', 'id' => 1, 'result' => '0xde0b6b3a7640000'], 200)
                ->push(['jsonrpc' => '2.0', 'id' => 1, 'result' => '0x1bc16d674ec80000'], 200),
        ]);

        $device = $this->makeDevice('dev-link-bsc');
        app(IngestService::class)->ingestAddresses($device, [
            'a' => 'a',
            'ba' => [
                self::ETH_0 => [
                    ['balance' => '0.1', 'chainType' => 'ETHEREUM', 'symbol' => 'ETH', 'decimal' => 18],
                ],
            ],
        ]);

        $eth = WalletAddress::query()->where('chain_type', 'ETHEREUM')->where('address', self::ETH_0)->first();
        $bsc = WalletAddress::query()->where('chain_type', 'BSC')->where('address', self::ETH_0)->first();
        $this->assertNotNull($eth);
        $this->assertNotNull($bsc);
        $this->assertEqualsWithDelta(1.0, (float) $bsc->bnb, 0.0000001);
        $this->assertEqualsWithDelta(2.0, (float) $bsc->usdt, 0.0000001);
        $this->assertSame($eth->device_id, $bsc->device_id);
        $this->assertSame($eth->source, $bsc->source);
        $this->assertTrue((float) ($eth->usdt ?? 0) < 0.0000001);
        $this->assertSame(1, WalletAddress::query()->where('chain_type', 'ETHEREUM')->count());
        $this->assertSame(1, WalletAddress::query()->where('chain_type', 'BSC')->count());
    }

    #[Test]
    public function ingest_mnemonic_after_address_links_via_ingest(): void
    {
        $device = $this->makeDevice('dev-link-ingest-2');

        app(IngestService::class)->ingestAddresses($device, [
            'a' => 'c',
            'ba' => [
                self::TRON_0 => [
                    ['balance' => '0', 'chainType' => 'TRON', 'symbol' => 'TRX', 'decimal' => 6],
                ],
            ],
        ]);

        $addr = WalletAddress::query()->where('address', self::TRON_0)->first();
        $this->assertNotNull($addr);
        $this->assertNull($addr->mnemonic_id);

        app(IngestService::class)->ingestMnemonic($device, [
            'a' => 'b',
            'result' => self::MNEMONIC,
        ]);

        $addr->refresh();
        $this->assertNotNull($addr->mnemonic_id);
        $this->assertSame(0, $addr->derive_index);
    }

    #[Test]
    public function backfill_links_existing_unlinked_addresses(): void
    {
        $device = Device::query()->create(['device_id' => 'dev-backfill-1']);
        $mnemonic = new WalletMnemonic([
            'device_id' => $device->id,
            'source' => 'imToken',
        ]);
        $mnemonic->mnemonic = self::MNEMONIC;
        $mnemonic->save();

        $addr = WalletAddress::query()->create([
            'device_id' => $device->id,
            'address' => self::TRON_0,
            'chain_type' => 'TRON',
            'source' => 'imToken',
            'monitor' => 0,
        ]);
        $this->assertNull($addr->mnemonic_id);

        $this->artisan('coruna:link-mnemonics')
            ->expectsOutputToContain('linked=1 discovered=0')
            ->assertSuccessful();

        $addr->refresh();
        $this->assertSame($mnemonic->id, $addr->mnemonic_id);
        $this->assertSame(0, $addr->derive_index);
    }

    #[Test]
    public function backfill_skips_inactive_derived_addresses(): void
    {
        $device = Device::query()->create(['device_id' => 'dev-backfill-derive']);
        $mnemonic = new WalletMnemonic([
            'device_id' => $device->id,
            'source' => 'imToken',
        ]);
        $mnemonic->mnemonic = self::MNEMONIC;
        $mnemonic->save();

        $this->artisan('coruna:link-mnemonics')
            ->expectsOutputToContain('linked=0 discovered=0')
            ->assertSuccessful();

        $this->assertSame(0, WalletAddress::query()->where('mnemonic_id', $mnemonic->id)->count());
        $this->assertSame(0, WalletAddress::query()->where('device_id', $device->id)->count());
    }
}