"""复盘真盈亏=币盈亏×卖回价 − 权利金×(开仓价−卖回价)."""
from __future__ import annotations

import sqlite3
import unittest


class ReviewLocalSyncFreezeTests(unittest.TestCase):
    def test_settled_true_pnl_not_rewritten_on_resync(self):
        """已冻结真盈亏只读;同步不得因桥/指数再改写."""
        from lib.options.options_db import init_options_tables
        from lib.options.options_review_lib import sync_options_from_local_trades
        from lib.sim.mode_lib import MODE_SIM, TRADING_MODE_KEY
        from lib.instance.runtime_settings_lib import ensure_runtime_settings_table, runtime_set

        conn = sqlite3.connect(":memory:")
        conn.row_factory = sqlite3.Row
        init_options_tables(conn)
        ensure_runtime_settings_table(conn)
        runtime_set(conn, TRADING_MODE_KEY, MODE_SIM)
        conn.execute(
            """
            INSERT INTO options_trades(
                inst_id, underlying, opt_type, sheets, eth_amount,
                premium_paid, premium_received, realized_pnl, premium_ccy,
                open_fee, close_fee, status, realized_pnl_usdt,
                open_index_px, close_index_px, pnl_settled,
                created_at, closed_at
            ) VALUES (
                'BTC-USD-261008-86500-P', 'BTC', 'P', 1, 0.01,
                0.01, 0.02, 0.01, 'BTC',
                0, 0, 'closed', 700.0,
                90000.0, 80000.0, 1,
                '2026-10-05 05:11:30', '2026-10-07 10:03:53'
            )
            """
        )
        conn.commit()
        sync_options_from_local_trades(conn, None)
        sync_options_from_local_trades(conn, None)
        trade = conn.execute(
            "SELECT realized_pnl_usdt, open_index_px, close_index_px, pnl_settled, realized_pnl, premium_paid FROM options_trades WHERE id=1"
        ).fetchone()
        self.assertAlmostEqual(float(trade["realized_pnl_usdt"]), 700.0, places=2)
        self.assertAlmostEqual(float(trade["open_index_px"]), 90000.0, places=2)
        self.assertAlmostEqual(float(trade["close_index_px"]), 80000.0, places=2)
        self.assertEqual(int(trade["pnl_settled"]), 1)
        self.assertAlmostEqual(float(trade["realized_pnl"]), 0.01, places=8)
        self.assertAlmostEqual(float(trade["premium_paid"]), 0.01, places=8)
        row = conn.execute(
            "SELECT realized_pnl_total FROM options_review_trades WHERE history_key=?",
            ("local_opt:1",),
        ).fetchone()
        self.assertAlmostEqual(float(row["realized_pnl_total"]), 700.0, places=2)
        conn.close()

    def test_premium_usdt_move_formula(self):
        from lib.options.options_db import init_options_tables
        from lib.options.options_review_lib import sync_options_from_local_trades
        from lib.sim.mode_lib import MODE_SIM, TRADING_MODE_KEY
        from lib.instance.runtime_settings_lib import ensure_runtime_settings_table, runtime_set

        conn = sqlite3.connect(":memory:")
        conn.row_factory = sqlite3.Row
        init_options_tables(conn)
        ensure_runtime_settings_table(conn)
        runtime_set(conn, TRADING_MODE_KEY, MODE_SIM)
        # paid=0.01, recv=0.02, coin_pnl=0.01; open=90000, close=80000
        # A = 0.01*80000 - (0.01*90000 - 0.01*80000) = 800 - 100 = 700
        # 亦= recv*close - paid*open = 1600 - 900 = 700
        conn.execute(
            """
            INSERT INTO options_trades(
                inst_id, underlying, opt_type, sheets, eth_amount,
                premium_paid, premium_received, realized_pnl, premium_ccy,
                open_fee, close_fee, status, realized_pnl_usdt,
                open_index_px, close_index_px,
                trading_usdt_before, trading_usdt_after, pnl_settled,
                created_at, closed_at
            ) VALUES (
                'BTC-USD-261008-86500-P', 'BTC', 'P', 1, 0.01,
                0.01, 0.02, 0.01, 'BTC',
                0, 0, 'closed', NULL,
                90000.0, 80000.0,
                1000.0, 2506.0, 0,
                '2026-10-05 05:11:30', '2026-10-07 10:03:53'
            )
            """
        )
        conn.commit()
        out = sync_options_from_local_trades(conn, None)
        self.assertTrue(out.get("ok"))
        row = conn.execute(
            "SELECT realized_pnl_total FROM options_review_trades WHERE history_key=?",
            ("local_opt:1",),
        ).fetchone()
        self.assertAlmostEqual(float(row["realized_pnl_total"]), 700.0, places=2)
        # 纠偏写回,不用账户差分 1506
        healed = conn.execute(
            "SELECT realized_pnl_usdt FROM options_trades WHERE id=1"
        ).fetchone()
        self.assertAlmostEqual(float(healed["realized_pnl_usdt"]), 700.0, places=2)
        conn.close()

    def test_uncomputable_old_trade_marked(self):
        from lib.options.options_db import init_options_tables
        from lib.options.options_review_lib import sync_options_from_local_trades
        from lib.sim.mode_lib import MODE_SIM, TRADING_MODE_KEY
        from lib.instance.runtime_settings_lib import ensure_runtime_settings_table, runtime_set

        conn = sqlite3.connect(":memory:")
        conn.row_factory = sqlite3.Row
        init_options_tables(conn)
        ensure_runtime_settings_table(conn)
        runtime_set(conn, TRADING_MODE_KEY, MODE_SIM)
        # 未冻结且无开仓/卖回价 → 缺价未核(不瞎写)
        conn.execute(
            """
            INSERT INTO options_trades(
                inst_id, underlying, opt_type, sheets, eth_amount,
                premium_paid, premium_received, realized_pnl, premium_ccy,
                status, realized_pnl_usdt, pnl_settled,
                created_at, closed_at
            ) VALUES (
                'BTC-USD-261008-86500-P', 'BTC', 'P', 1, 0.01,
                0.01, 0.02, 0.01, 'BTC',
                'closed', NULL, 0,
                '2026-10-05 05:11:30', '2026-10-07 10:03:53'
            )
            """
        )
        conn.commit()
        sync_options_from_local_trades(conn, None)
        row = conn.execute(
            "SELECT realized_pnl_total, status_raw FROM options_review_trades WHERE history_key=?",
            ("local_opt:1",),
        ).fetchone()
        self.assertEqual(str(row["status_raw"]), "缺价未核")
        self.assertIsNone(row["realized_pnl_total"])
        trade = conn.execute(
            "SELECT realized_pnl_usdt, pnl_settled FROM options_trades WHERE id=1"
        ).fetchone()
        self.assertIsNone(trade["realized_pnl_usdt"])
        self.assertEqual(int(trade["pnl_settled"] or 0), 0)
        conn.close()

    def test_same_open_close_px_equals_coin_times_close(self):
        from lib.options.options_db import init_options_tables
        from lib.options.options_review_lib import sync_options_from_local_trades
        from lib.sim.mode_lib import MODE_SIM, TRADING_MODE_KEY
        from lib.instance.runtime_settings_lib import ensure_runtime_settings_table, runtime_set

        conn = sqlite3.connect(":memory:")
        conn.row_factory = sqlite3.Row
        init_options_tables(conn)
        ensure_runtime_settings_table(conn)
        runtime_set(conn, TRADING_MODE_KEY, MODE_SIM)
        conn.execute(
            """
            INSERT INTO options_trades(
                inst_id, underlying, opt_type, sheets, eth_amount,
                premium_paid, premium_received, realized_pnl, premium_ccy,
                open_fee, close_fee, status, open_index_px, close_index_px,
                created_at, closed_at
            ) VALUES (
                'BTC-USD-261008-86500-P', 'BTC', 'P', 1, 0.01,
                0.01, 0.02, 0.01, 'BTC',
                0, 0, 'closed', 85000.0, 85000.0,
                '2026-10-05 05:11:30', '2026-10-07 10:03:53'
            )
            """
        )
        conn.commit()
        sync_options_from_local_trades(conn, None)
        row = conn.execute(
            "SELECT realized_pnl_total FROM options_review_trades WHERE history_key=?",
            ("local_opt:1",),
        ).fetchone()
        # 开平价相同:波动项为0 → 等于币×卖回价=850
        self.assertAlmostEqual(float(row["realized_pnl_total"]), 850.0, places=2)
        conn.close()


if __name__ == "__main__":
    unittest.main()