<?php

declare(strict_types=1);

namespace ApiModel\Tests\Integration\Http;

use ApiModel\Action\PurchasesAction;
use ApiModel\Infrastructure\Persistence\Repositories\PdoBillRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoPurchasePaymentRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoExpenseRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoJournalRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoChartAccountRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoTaxRateRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoCompanyRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoBranchRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoExchangeRateRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoUserAccessRepository;
use ApiModel\Infrastructure\Persistence\Repositories\PdoProfileRepository;
use ApiModel\Middleware\CompanyContextMiddleware;
use ApiModel\Middleware\ApiErrorHandler;
use ApiModel\Route\PurchasesRoutes;
use ApiModel\Service\BillService;
use ApiModel\Service\PurchasePaymentService;
use ApiModel\Service\ExpenseService;
use ApiModel\Service\JournalService;
use ApiModel\Service\OrganizationService;
use Firebase\JWT\JWT;
use PDO;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\ResponseInterface;
use Slim\App;
use Slim\Factory\AppFactory;
use Slim\Psr7\Factory\ServerRequestFactory;
use Slim\Psr7\Factory\StreamFactory;

final class PurchasesBillsRoutesTest extends TestCase
{
    private PDO $pdo;
    private App $app;
    private string $adminToken;

    private const ADMIN_USER_ID = '11111111-1111-1111-1111-111111111111';
    private const ADMIN_ROLE_ID = '33333333-3333-3333-3333-333333333333';
    private const COMPANY_ID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa';
    private const BRANCH_ID = 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb';
    private const VENDOR_ID = 'v1111111-1111-1111-1111-111111111111';

    private const PAYABLE_ACCOUNT_ID = '22050500-0000-0000-0000-000000000001';
    private const EXPENSE_ACCOUNT_ID = '51050500-0000-0000-0000-000000000002';
    private const TAX_ACCOUNT_ID = '24080500-0000-0000-0000-000000000003';
    private const DISCOUNT_ACCOUNT_ID = '42100500-0000-0000-0000-000000000004';
    private const TAX_RATE_ID = 't1111111-1111-1111-1111-111111111111';

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

        $this->pdo = new PDO('sqlite::memory:');
        $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        $this->pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);

        $this->createSchema();
        $this->seedData();
        $this->configureEnv();

        $this->app = $this->buildApp();
        $this->adminToken = $this->issueToken(self::ADMIN_USER_ID, 'ADMINISTRADOR');
    }

    private function companyHeaders(): array
    {
        return [
            'Authorization' => 'Bearer ' . $this->adminToken,
            'X-Company-Id' => self::COMPANY_ID,
        ];
    }

    public function testListBillsInitiallyEmpty(): void
    {
        $response = $this->request('GET', '/purchases/bills', $this->companyHeaders());

        $this->assertSame(200, $response->getStatusCode());
        $body = $this->decodeBody($response);
        $this->assertCount(0, $body);
    }

    public function testCreateDraftBillSuccessNoAccounting(): void
    {
        $payload = [
            'vendor_id' => self::VENDOR_ID,
            'payable_account_id' => self::PAYABLE_ACCOUNT_ID,
            'bill_date' => '2026-06-22',
            'due_date' => '2026-07-22',
            'reference' => 'BILL-REF-01',
            'discount_amount' => 0.0,
            'status' => 'draft',
            'notes' => 'Draft vendor bill notes',
            'lines' => [
                [
                    'chart_account_id' => self::EXPENSE_ACCOUNT_ID,
                    'description' => 'Suministros de oficina',
                    'quantity' => 5.0,
                    'price' => 20.0,
                    'tax_rate_id' => null,
                ]
            ]
        ];

        $response = $this->jsonRequest('POST', '/purchases/bills', $payload, $this->companyHeaders());
        $this->assertSame(200, $response->getStatusCode());

        $bill = $this->decodeBody($response);
        $this->assertArrayHasKey('id', $bill);
        $this->assertSame('draft', $bill['status']);
        $this->assertEquals(100.0, $bill['total']);
        $this->assertEquals(100.0, $bill['balance']);
        $this->assertCount(1, $bill['lines']);

        // Assert no accounting entry created for draft bill
        $stmt = $this->pdo->prepare('SELECT COUNT(*) FROM journal_entries WHERE entry_number = ?');
        $stmt->execute([$bill['bill_number']]);
        $this->assertEquals(0, $stmt->fetchColumn());
    }

    public function testCreatePostedBillGeneratesAccountingEntries(): void
    {
        $payload = [
            'vendor_id' => self::VENDOR_ID,
            'payable_account_id' => self::PAYABLE_ACCOUNT_ID,
            'bill_date' => '2026-06-22',
            'due_date' => '2026-07-22',
            'reference' => 'BILL-REF-02',
            'discount_amount' => 15.0, // Discount received
            'status' => 'posted',
            'notes' => 'Posted notes',
            'lines' => [
                [
                    'chart_account_id' => self::EXPENSE_ACCOUNT_ID,
                    'description' => 'Servicio Tecnico',
                    'quantity' => 1.0,
                    'price' => 200.0,
                    'tax_rate_id' => self::TAX_RATE_ID, // 15% on 200 = 30.0 Tax
                ]
            ]
        ];

        $response = $this->jsonRequest('POST', '/purchases/bills', $payload, $this->companyHeaders());
        $this->assertSame(200, $response->getStatusCode());

        $bill = $this->decodeBody($response);
        $this->assertSame('posted', $bill['status']);
        $this->assertEquals(200.0, $bill['subtotal']);
        $this->assertEquals(30.0, $bill['tax_amount']);
        $this->assertEquals(215.0, $bill['total']); // 200 + 30 - 15 = 215.0

        // Assert accounting entry exists
        $stmt = $this->pdo->prepare('SELECT id, status FROM journal_entries WHERE entry_number = ? LIMIT 1');
        $stmt->execute([$bill['bill_number']]);
        $entry = $stmt->fetch();
        $this->assertNotFalse($entry);
        $this->assertSame('posted', $entry['status']);

        // Assert journal lines:
        // 1. Credit Payable: 215.0
        // 2. Debit Expense: 200.0
        // 3. Debit Tax: 30.0
        // 4. Credit Discount: 15.0
        $stmtLines = $this->pdo->prepare('SELECT chart_account_id, debit, credit FROM journal_lines WHERE journal_entry_id = ? ORDER BY line_order ASC');
        $stmtLines->execute([$entry['id']]);
        $lines = $stmtLines->fetchAll();

        $this->assertCount(4, $lines);

        $this->assertSame(self::PAYABLE_ACCOUNT_ID, $lines[0]['chart_account_id']);
        $this->assertEquals(0.0, $lines[0]['debit']);
        $this->assertEquals(215.0, $lines[0]['credit']);

        $this->assertSame(self::EXPENSE_ACCOUNT_ID, $lines[1]['chart_account_id']);
        $this->assertEquals(200.0, $lines[1]['debit']);
        $this->assertEquals(0.0, $lines[1]['credit']);

        $this->assertSame(self::TAX_ACCOUNT_ID, $lines[2]['chart_account_id']);
        $this->assertEquals(30.0, $lines[2]['debit']);
        $this->assertEquals(0.0, $lines[2]['credit']);

        $this->assertSame(self::DISCOUNT_ACCOUNT_ID, $lines[3]['chart_account_id']);
        $this->assertEquals(0.0, $lines[3]['debit']);
        $this->assertEquals(15.0, $lines[3]['credit']);
    }

    public function testDeleteBillRemovesAccounting(): void
    {
        $payload = [
            'vendor_id' => self::VENDOR_ID,
            'payable_account_id' => self::PAYABLE_ACCOUNT_ID,
            'bill_date' => '2026-06-22',
            'due_date' => '2026-07-22',
            'status' => 'posted',
            'lines' => [
                [
                    'chart_account_id' => self::EXPENSE_ACCOUNT_ID,
                    'quantity' => 1.0,
                    'price' => 80.0,
                ]
            ]
        ];

        $res = $this->jsonRequest('POST', '/purchases/bills', $payload, $this->companyHeaders());
        $bill = $this->decodeBody($res);
        $billId = $bill['id'];
        $billNumber = $bill['bill_number'];

        // Confirm accounting entry exists
        $stmt = $this->pdo->prepare('SELECT COUNT(*) FROM journal_entries WHERE entry_number = ?');
        $stmt->execute([$billNumber]);
        $this->assertEquals(1, $stmt->fetchColumn());

        // Delete bill
        $delRes = $this->request('DELETE', '/purchases/bills/' . $billId, $this->companyHeaders());
        $this->assertSame(200, $delRes->getStatusCode());

        // Confirm bill is deleted
        $stmtBill = $this->pdo->prepare('SELECT COUNT(*) FROM purchases_bills WHERE id = ?');
        $stmtBill->execute([$billId]);
        $this->assertEquals(0, $stmtBill->fetchColumn());

        // Confirm accounting entry is deleted
        $stmtJe = $this->pdo->prepare('SELECT COUNT(*) FROM journal_entries WHERE entry_number = ?');
        $stmtJe->execute([$billNumber]);
        $this->assertEquals(0, $stmtJe->fetchColumn());
    }

    private function buildApp(): App
    {
        $app = AppFactory::create();

        $orgRepo = new PdoCompanyRepository($this->pdo);
        $branchRepo = new PdoBranchRepository($this->pdo);
        $uaRepo = new PdoUserAccessRepository($this->pdo);
        $profRepo = new PdoProfileRepository($this->pdo);
        $orgService = new OrganizationService($orgRepo, $branchRepo, $uaRepo, $profRepo);
        
        $companyMiddleware = new CompanyContextMiddleware($orgService);

        $billRepo = new PdoBillRepository($this->pdo);
        $purchasePaymentRepo = new PdoPurchasePaymentRepository($this->pdo);
        $expenseRepo = new PdoExpenseRepository($this->pdo);
        $journalRepo = new PdoJournalRepository($this->pdo);
        $taxRateRepo = new PdoTaxRateRepository($this->pdo);
        $chartAccountRepo = new PdoChartAccountRepository($this->pdo);
        $exchangeRateRepo = new PdoExchangeRateRepository($this->pdo);

        $journalService = new JournalService($journalRepo, $chartAccountRepo, $orgRepo, $branchRepo, $exchangeRateRepo);
        
        $billService = new BillService($billRepo, $journalRepo, $taxRateRepo, $journalService, $this->pdo);
        $purchasePaymentService = new PurchasePaymentService($purchasePaymentRepo, $billRepo, $journalRepo, $journalService, $this->pdo);
        $expenseService = new ExpenseService($expenseRepo, $journalRepo, $taxRateRepo, $journalService, $this->pdo);

        $action = new PurchasesAction($billService, $purchasePaymentService, $expenseService);

        $uuid = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
        $app->group('', function ($g) use ($action, $uuid): void {
            PurchasesRoutes::register($g, $action, $uuid);
        });

        $app->addRoutingMiddleware();
        $app->add($companyMiddleware);
        $errorMiddleware = $app->addErrorMiddleware(false, true, true);
        $errorMiddleware->setDefaultErrorHandler(ApiErrorHandler::create($app->getResponseFactory()));

        return $app;
    }

    private function request(string $method, string $path, array $headers = []): ResponseInterface
    {
        $requestFactory = new ServerRequestFactory();
        $request = $requestFactory->createServerRequest($method, $path);
        foreach ($headers as $name => $value) {
            $request = $request->withHeader($name, $value);
        }

        return $this->app->handle($request);
    }

    private function jsonRequest(string $method, string $path, array $payload, array $headers = []): ResponseInterface
    {
        $streamFactory = new StreamFactory();
        $requestFactory = new ServerRequestFactory();
        $body = $streamFactory->createStream((string) json_encode($payload, JSON_THROW_ON_ERROR));

        $request = $requestFactory
            ->createServerRequest($method, $path)
            ->withHeader('Content-Type', 'application/json')
            ->withBody($body);

        foreach ($headers as $name => $value) {
            $request = $request->withHeader($name, $value);
        }

        return $this->app->handle($request);
    }

    private function decodeBody(ResponseInterface $response): array
    {
        $raw = (string) $response->getBody();
        $data = json_decode($raw, true);

        return is_array($data) ? $data : [];
    }

    private function issueToken(string $userId, string $role): string
    {
        return JWT::encode([
            'sub' => $userId,
            'role' => $role,
            'lang' => 'es',
            'iat' => time(),
            'exp' => time() + 3600,
        ], (string) $_ENV['JWT_SECRET'], 'HS256');
    }

    private function createSchema(): void
    {
        $this->pdo->exec("ATTACH DATABASE ':memory:' AS auth");

        $this->pdo->exec(
            'CREATE TABLE auth.roles (
                id TEXT PRIMARY KEY,
                name_es TEXT NOT NULL UNIQUE,
                name_en TEXT NOT NULL UNIQUE,
                description_es TEXT,
                description_en TEXT,
                is_active INTEGER NOT NULL DEFAULT 1
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE auth.users (
                id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                email TEXT NOT NULL UNIQUE,
                password_hash TEXT NULL,
                language TEXT NOT NULL DEFAULT "es",
                is_active INTEGER NOT NULL DEFAULT 1
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE auth.role_user (
                role_id TEXT NOT NULL,
                user_id TEXT NOT NULL,
                PRIMARY KEY (role_id, user_id)
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE companies (
                id TEXT PRIMARY KEY,
                legal_name TEXT NOT NULL,
                trade_name TEXT,
                tax_id TEXT NOT NULL UNIQUE,
                base_currency TEXT NOT NULL DEFAULT "USD",
                email TEXT,
                phone TEXT,
                address TEXT,
                is_active INTEGER NOT NULL DEFAULT 1,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE branches (
                id TEXT PRIMARY KEY,
                company_id TEXT NOT NULL,
                name TEXT NOT NULL,
                code TEXT,
                address TEXT,
                phone TEXT,
                is_main INTEGER NOT NULL DEFAULT 0,
                operating_currency TEXT NOT NULL DEFAULT "USD",
                is_active INTEGER NOT NULL DEFAULT 1,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, code)
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE user_access (
                id TEXT PRIMARY KEY,
                user_id TEXT NOT NULL,
                company_id TEXT NOT NULL,
                branch_id TEXT,
                can_manage INTEGER NOT NULL DEFAULT 0,
                is_default INTEGER NOT NULL DEFAULT 0,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (user_id, company_id)
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE contacts (
                id TEXT PRIMARY KEY,
                company_id TEXT NOT NULL REFERENCES companies(id),
                type TEXT NOT NULL,
                name TEXT NOT NULL,
                tax_id TEXT NULL,
                email TEXT NULL,
                phone TEXT NULL,
                address TEXT NULL,
                is_active INTEGER NOT NULL DEFAULT 1,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, tax_id)
            )'
        );

        $this->pdo->exec(
            'CREATE TABLE chart_accounts (
                id TEXT PRIMARY KEY,
                parent_id TEXT NULL,
                company_id TEXT NOT NULL,
                code TEXT NOT NULL,
                name TEXT NOT NULL,
                account_type TEXT NOT NULL,
                is_header INTEGER NOT NULL DEFAULT 0,
                is_active INTEGER NOT NULL DEFAULT 1,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, code)
            )'
        );

        $this->pdo->exec(
            'CREATE TABLE tax_rates (
                id TEXT PRIMARY KEY,
                company_id TEXT NOT NULL REFERENCES companies(id),
                name TEXT NOT NULL,
                rate REAL NOT NULL,
                type TEXT NOT NULL,
                is_active INTEGER NOT NULL DEFAULT 1,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, name)
            )'
        );

        $this->pdo->exec(
            'CREATE TABLE exchange_rates (
                id TEXT PRIMARY KEY,
                company_id TEXT NOT NULL,
                rate_date TEXT NOT NULL,
                from_currency TEXT NOT NULL,
                to_currency TEXT NOT NULL,
                rate REAL NOT NULL,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, rate_date, from_currency, to_currency)
            )',
        );

        $this->pdo->exec(
            'CREATE TABLE journal_entries (
                id TEXT PRIMARY KEY,
                company_id TEXT NOT NULL,
                branch_id TEXT,
                entry_number TEXT NOT NULL,
                entry_date TEXT NOT NULL,
                description TEXT,
                status TEXT NOT NULL DEFAULT "draft",
                operating_currency TEXT NOT NULL,
                functional_currency TEXT NOT NULL,
                exchange_rate REAL NOT NULL,
                created_by TEXT,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, entry_number)
            )'
        );

        $this->pdo->exec(
            'CREATE TABLE journal_lines (
                id TEXT PRIMARY KEY,
                journal_entry_id TEXT NOT NULL REFERENCES journal_entries(id) ON DELETE CASCADE,
                chart_account_id TEXT NOT NULL REFERENCES chart_accounts(id),
                description TEXT,
                debit REAL NOT NULL DEFAULT 0,
                credit REAL NOT NULL DEFAULT 0,
                debit_functional REAL NOT NULL DEFAULT 0,
                credit_functional REAL NOT NULL DEFAULT 0,
                line_order INTEGER NOT NULL DEFAULT 0
            )'
        );

        $this->pdo->exec(
            'CREATE TABLE purchases_bills (
                id TEXT PRIMARY KEY,
                company_id TEXT NOT NULL,
                branch_id TEXT,
                vendor_id TEXT NOT NULL,
                payable_account_id TEXT NOT NULL,
                bill_number TEXT NOT NULL,
                bill_date TEXT NOT NULL,
                due_date TEXT NOT NULL,
                reference TEXT,
                currency_code TEXT NOT NULL DEFAULT "USD",
                exchange_rate REAL NOT NULL DEFAULT 1.0,
                discount_amount REAL NOT NULL DEFAULT 0.0,
                tax_amount REAL NOT NULL DEFAULT 0.0,
                subtotal REAL NOT NULL DEFAULT 0.0,
                total REAL NOT NULL DEFAULT 0.0,
                balance REAL NOT NULL DEFAULT 0.0,
                status TEXT NOT NULL DEFAULT "draft",
                notes TEXT,
                created_by TEXT,
                created_at TEXT DEFAULT CURRENT_TIMESTAMP,
                updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
                UNIQUE (company_id, vendor_id, bill_number)
            )'
        );

        $this->pdo->exec(
            'CREATE TABLE purchases_bill_lines (
                id TEXT PRIMARY KEY,
                bill_id TEXT NOT NULL REFERENCES purchases_bills(id) ON DELETE CASCADE,
                description TEXT,
                quantity REAL NOT NULL DEFAULT 1.0,
                price REAL NOT NULL DEFAULT 0.0,
                tax_rate_id TEXT,
                tax_amount REAL NOT NULL DEFAULT 0.0,
                total REAL NOT NULL DEFAULT 0.0,
                chart_account_id TEXT NOT NULL,
                line_order INTEGER NOT NULL DEFAULT 0
            )'
        );
    }

    private function seedData(): void
    {
        $this->pdo->prepare(
            'INSERT INTO auth.users (id, name, email, password_hash, is_active) VALUES (?,?,?, "hash", 1)'
        )->execute([self::ADMIN_USER_ID, 'Admin User', 'admin@example.com']);

        $this->pdo->prepare(
            'INSERT INTO auth.roles (id, name_es, name_en) VALUES (?,?,?)'
        )->execute([self::ADMIN_ROLE_ID, 'ADMINISTRADOR', 'ADMINISTRATOR']);

        $this->pdo->prepare('INSERT INTO auth.role_user (role_id, user_id) VALUES (?,?)')
            ->execute([self::ADMIN_ROLE_ID, self::ADMIN_USER_ID]);

        $this->pdo->prepare(
            'INSERT INTO companies (id, legal_name, trade_name, tax_id, base_currency, is_active)
             VALUES (?,?,?,?,?,1)'
        )->execute([self::COMPANY_ID, 'Empresa Demo', 'Demo', '900111222-3', 'USD']);

        $this->pdo->prepare(
            'INSERT INTO branches (id, company_id, name, code, is_main, operating_currency, is_active)
             VALUES (?,?,?,?,1,?,1)'
        )->execute([self::BRANCH_ID, self::COMPANY_ID, 'Principal', 'MAIN', 'USD']);

        $this->pdo->prepare(
            'INSERT INTO user_access (id, user_id, company_id, branch_id, can_manage, is_default)
             VALUES (?,?,?,?,1,1)'
        )->execute(['cccccccc-cccc-cccc-cccc-cccccccccccc', self::ADMIN_USER_ID, self::COMPANY_ID, self::BRANCH_ID]);

        // Seed Vendor
        $this->pdo->prepare('INSERT INTO contacts (id, company_id, type, name, is_active) VALUES (?,?,?,?,1)')
            ->execute([self::VENDOR_ID, self::COMPANY_ID, 'vendor', 'Proveedor Test']);

        // Seed Accounts
        $this->pdo->prepare('INSERT INTO chart_accounts (id, company_id, code, name, account_type, is_header) VALUES (?,?,?,?,?,0)')
            ->execute([self::PAYABLE_ACCOUNT_ID, self::COMPANY_ID, '220505', 'Proveedores Nacionales', 'liability']);

        $this->pdo->prepare('INSERT INTO chart_accounts (id, company_id, code, name, account_type, is_header) VALUES (?,?,?,?,?,0)')
            ->execute([self::EXPENSE_ACCOUNT_ID, self::COMPANY_ID, '510505', 'Gastos Diversos', 'expense']);

        $this->pdo->prepare('INSERT INTO chart_accounts (id, company_id, code, name, account_type, is_header) VALUES (?,?,?,?,?,0)')
            ->execute([self::TAX_ACCOUNT_ID, self::COMPANY_ID, '240805', 'IVA Descontable', 'liability']);

        $this->pdo->prepare('INSERT INTO chart_accounts (id, company_id, code, name, account_type, is_header) VALUES (?,?,?,?,?,0)')
            ->execute([self::DISCOUNT_ACCOUNT_ID, self::COMPANY_ID, '421005', 'Descuentos en Compras', 'income']);

        // Seed Tax Rate
        $this->pdo->prepare('INSERT INTO tax_rates (id, company_id, name, rate, type, is_active) VALUES (?,?,?,?,?,1)')
            ->execute([self::TAX_RATE_ID, self::COMPANY_ID, 'IVA 15%', 15.0, 'vat']);
    }

    private function configureEnv(): void
    {
        $_ENV['JWT_SECRET'] = 'test-jwt-secret';
        $_ENV['JWT_EXPIRES_IN'] = '15m';
        $_ENV['JWT_REFRESH_EXPIRES_DAYS'] = '7';
        $_ENV['JWT_KID'] = '';
        $_ENV['JWT_SECRET_PREVIOUS'] = '';
    }
}
