from dataclasses import dataclass
from loguru import logger

SAR_TO_USD = 0.2667  # 1 SAR ≈ 0.2667 USD (fixed rate)


@dataclass
class MiningResult:
    # Miner info
    miner_name: str
    miner_hashrate: float
    miner_power_w: int
    coin: str

    # Revenue
    daily_coins: float
    daily_revenue_usd: float
    monthly_revenue_usd: float
    yearly_revenue_usd: float

    # Costs (SAR input, USD output)
    electricity_price_sar: float
    daily_electricity_cost_sar: float
    daily_electricity_cost_usd: float
    monthly_electricity_cost_sar: float
    monthly_electricity_cost_usd: float

    # Profit
    daily_profit_usd: float
    monthly_profit_usd: float
    yearly_profit_usd: float
    daily_profit_sar: float
    monthly_profit_sar: float

    # Ratios
    profitability_ratio: float  # revenue / electricity cost
    break_even_days: float
    coin_price_usd: float
    network_hashrate_ths: float
    difficulty: float
    algorithm: str


def calculate_mining_profit(
    hashrate_ths: float,
    power_w: int,
    electricity_sar_per_kwh: float,
    coin_price_usd: float,
    block_reward: float,
    block_time_seconds: int,
    difficulty: float,
    network_hashrate_ths: float,
    miner_name: str = "Unknown",
    coin: str = "BTC",
    algorithm: str = "SHA-256",
) -> MiningResult:
    """
    Core mining profitability calculator.

    Revenue formula:
      blocks_per_day = 86400 / block_time
      miner_share = hashrate / network_hashrate
      coins_per_day = blocks_per_day * block_reward * miner_share

    Electricity cost:
      kWh_per_day = (power_w / 1000) * 24
      cost_sar = kWh_per_day * electricity_price_sar
    """
    # Guard against zero division
    if network_hashrate_ths <= 0 or difficulty <= 0 or block_time_seconds <= 0:
        logger.warning(f"Invalid mining params for {coin}")
        network_hashrate_ths = max(network_hashrate_ths, 1.0)
        block_time_seconds = max(block_time_seconds, 1)

    blocks_per_day = 86400 / block_time_seconds
    miner_share = hashrate_ths / network_hashrate_ths
    daily_coins = blocks_per_day * block_reward * miner_share

    daily_revenue_usd = daily_coins * coin_price_usd
    monthly_revenue_usd = daily_revenue_usd * 30
    yearly_revenue_usd = daily_revenue_usd * 365

    # Electricity costs
    kwh_per_day = (power_w / 1000) * 24
    daily_cost_sar = kwh_per_day * electricity_sar_per_kwh
    daily_cost_usd = daily_cost_sar * SAR_TO_USD
    monthly_cost_sar = daily_cost_sar * 30
    monthly_cost_usd = daily_cost_usd * 30

    # Profit
    daily_profit_usd = daily_revenue_usd - daily_cost_usd
    monthly_profit_usd = monthly_revenue_usd - monthly_cost_usd
    yearly_profit_usd = yearly_revenue_usd - (daily_cost_usd * 365)
    daily_profit_sar = daily_profit_usd / SAR_TO_USD
    monthly_profit_sar = monthly_profit_usd / SAR_TO_USD

    profitability_ratio = (
        daily_revenue_usd / daily_cost_usd if daily_cost_usd > 0 else 0
    )

    # Break-even: assuming average miner cost ~$3000 USD
    avg_miner_cost_usd = 3000.0
    break_even_days = (
        avg_miner_cost_usd / daily_profit_usd if daily_profit_usd > 0 else float("inf")
    )

    return MiningResult(
        miner_name=miner_name,
        miner_hashrate=hashrate_ths,
        miner_power_w=power_w,
        coin=coin,
        daily_coins=round(daily_coins, 8),
        daily_revenue_usd=round(daily_revenue_usd, 4),
        monthly_revenue_usd=round(monthly_revenue_usd, 4),
        yearly_revenue_usd=round(yearly_revenue_usd, 4),
        electricity_price_sar=electricity_sar_per_kwh,
        daily_electricity_cost_sar=round(daily_cost_sar, 4),
        daily_electricity_cost_usd=round(daily_cost_usd, 4),
        monthly_electricity_cost_sar=round(monthly_cost_sar, 4),
        monthly_electricity_cost_usd=round(monthly_cost_usd, 4),
        daily_profit_usd=round(daily_profit_usd, 4),
        monthly_profit_usd=round(monthly_profit_usd, 4),
        yearly_profit_usd=round(yearly_profit_usd, 4),
        daily_profit_sar=round(daily_profit_sar, 4),
        monthly_profit_sar=round(monthly_profit_sar, 4),
        profitability_ratio=round(profitability_ratio, 4),
        break_even_days=round(break_even_days, 1) if break_even_days != float("inf") else -1,
        coin_price_usd=coin_price_usd,
        network_hashrate_ths=network_hashrate_ths,
        difficulty=difficulty,
        algorithm=algorithm,
    )