#!/usr/bin/env python3
"""Offline analytical scenarios; NOT an exact v4 quote or fork simulation.
USD is an illustrative accounting unit; debts actually denominated in ETH/CLAUS.
C is net position collateral, N=L*C. Upfront charge and gas paid separately.
"""
import argparse
import json
import math
from decimal import Decimal, ROUND_CEILING, ROUND_FLOOR
F = 0.023
ETH_USD = 2700.0  # conversion assumption, not a market observation
P0 = 0.001       # hypothetical USD/CLAUS; not observed
IMPACT = 0.01    # per-leg adverse execution factor, not a live quote
GAS = 4.05      # 500k gas * 3 gwei * illustrative $2700/ETH
KEEPER = 2.0    # separate incentive; liquidation gas charged in addition
SERVICE = 1.0

def position(side, c=100.0, leverage=2.0, ratio=1.0, charge=0.01,
             impact=IMPACT, gas=GAS, keeper=0.0):
    if side not in ('long', 'short') or c <= 0 or leverage < 1 or ratio < 0 or not 0 <= impact < 1:
        raise ValueError('invalid scenario')
    n = c * leverage
    a = n * charge
    if side == 'long':
        debt = n-c  # ETH debt in illustrative USD at fixed ETH/USD
        q = n*(1-F)/(P0*(1+impact))
        gross_sale = q*P0*ratio/(1+impact)
        available = gross_sale*(1-F)
        paid = min(debt, max(0, available-gas-keeper))
        loss = debt-paid
        equity = max(0, available-gas-keeper-debt)
        fees = F*(n+gross_sale)
        debt_units = debt/ETH_USD
        repaid_units = paid/ETH_USD
        loss_current = loss
        be = (c+debt+2*gas+a)*(1+impact)**2/(n*(1-F)**2)
        impact_cost = n*ratio*(1-F)**2-available
        health = available/debt if debt else float('inf')
    else:
        debt = n  # short borrows N/P0 CLAUS, not (L-1)C
        q = n/P0
        proceeds = n*(1-F)/(1+impact)
        available = c+proceeds
        buy_cost = n*ratio*(1+impact)/(1-F)
        usable = max(0, available-gas-keeper)
        fraction = min(1, usable/buy_cost) if buy_cost else 1.0
        paid = n*fraction
        loss = n-paid  # loss valued at entry price; token loss persists
        equity = max(0, usable-buy_cost)
        fees = F*(n/(1+impact)+buy_cost)
        debt_units = q
        repaid_units = q*fraction
        loss_current = loss*ratio
        be = (proceeds-2*gas-a)*(1-F)/(n*(1+impact))
        impact_cost = n*(1-F)-proceeds + buy_cost-n*ratio/(1-F)
        health = available/buy_cost if buy_cost else float('inf')
    return dict(side=side,collateral=c,leverage=leverage,price_ratio=ratio,
                notional=n,debt_entry_value=debt,debt_units=debt_units,
                repaid_units=repaid_units,bad_debt_units=debt_units-repaid_units,
                provider_principal_loss_entry_value=loss,
                provider_principal_loss_current_value=loss_current,
                user_equity_after_exit=equity,user_net_pnl=equity-c-a-gas,
                gross_user_cash_before_open_gas=c+a+gas+KEEPER,
                opening_charge=a,pool_project_platform_fees=fees,project_fee=fees*20/23,platform_fee=fees*3/23,
                adverse_impact_cost=impact_cost,open_gas=gas,close_gas=gas,keeper_reward=keeper,
                exit_health=health,break_even_price_ratio=be,
                provider_net_after_service=a-loss-SERVICE)

def capital(c,l,k,longs):
    shorts=k-longs
    eth_loans=longs*(l-1)*c
    token_loans=shorts*l*c/P0
    # 80% utilization: segregated cash buffer, not posted collateral.
    return dict(collateral_per_user=c,leverage=l,positions=k,longs=longs,shorts=shorts,
      posted_collateral=k*c,eth_loans_usd=eth_loans,eth_inventory=eth_loans/.8/ETH_USD,
      claus_loans=token_loans,claus_inventory=token_loans/.8,
      unlent_buffer_usd=(eth_loans+token_loans*P0)*.25,
      long_locked_claus=longs*l*c*(1-F)/(P0*(1+IMPACT)),
      short_locked_proceeds_usd=shorts*l*c*(1-F)/(1+IMPACT),
      separate_first_loss_reserve_usd=.1*(eth_loans+token_loans*P0),
      separate_gas_reserve_usd=k*(2*GAS+KEEPER),
      actual_pool_depth=None)

def results():
    capital_rows=[capital(c,l,k,j) for c in [50,100,250,500] for l in [1.5,2]
      for k in [1,5,10] for j in sorted(set([0,k,k//2]))]
    costs=[position(s,c,l,charge=a) for c in [50,100,250,500]
       for l in [1.5,2] for s in ['long','short'] for a in [0,.005,.01,.015]]
    stress=[position(s,100,l,r,keeper=KEEPER) for s in ['long','short']
      for l in [1.5,2] for r in [.9,1.1,.75,1.25,.5,1.5,.1,3,11]]
    outages=[]
    for minutes in [1,5,30]:
      # Assumed stress trajectory: +/-1% compounded each minute. Not a probability estimate.
      for s,base in [('long',.99),('short',1.01)]:
        outages.append(dict(minutes=minutes,assumed_price_ratio=base**minutes,
                            result=position(s,100,2,base**minutes,keeper=KEEPER)))
    depth=100000.0  # hypothetical virtual USD quote reserve
    impact_budget=.005
    gross_cap=depth*impact_budget/(1-F)
    manipulation=[]
    for r in [1.1,1.25,2,3,11]:
      gross_push=depth*(math.sqrt(r)-1)/(1-F)
      # Fee-only irrecoverable lower bound, includes reversal sell. Excludes arbitrage/MEV.
      reverse_gross=depth*(math.sqrt(r)-1)
      fee_floor=F*(gross_push+reverse_gross)
      manipulation.append(dict(price_ratio=r,hypothetical_gross_push=gross_push,
                               fee_only_attack_cost_lower_bound=fee_floor))
    return dict(assumptions=dict(eth_usd=ETH_USD,claus_usd=P0,total_pool_fee=F,
      adverse_impact_per_leg=IMPACT,gas_per_transaction_usd=GAS,gas_units=500000,
      gas_gwei=3,keeper_reward_usd=KEEPER,service_usd_per_position=SERVICE,
      max_utilization=.8,first_loss_reserve_fraction_of_loans=.1),
      capital=capital_rows,costs=costs,stress=stress,keeper_outages=outages,
      capacity=dict(actual_executable_depth=None,authorized_live_positions=0,
        hypothetical_virtual_quote_reserve_usd=depth,average_impact_budget=impact_budget,
        hypothetical_gross_order_cap= gross_cap,
        collateral_cap_at_1_5x=gross_cap/1.5,collateral_cap_at_2x=gross_cap/2,
        aggregate_gross_close_cap=gross_cap,
        manipulation_examples=manipulation))

def self_test():
    for side in ['long','short']:
      for c in [50,100,250,500]:
       for l in [1.5,2]:
        for r in [.0,.1,.5,1,3,11]:
         x=position(side,c,l,r)
         assert x['pool_project_platform_fees'] >= 0
         assert abs(x['project_fee']+x['platform_fee']-x['pool_project_platform_fees'])<1e-8
         assert abs(x['debt_units']-x['repaid_units']-x['bad_debt_units'])<1e-7
         assert x['bad_debt_units']>=-1e-8 and x['user_equity_after_exit']>=0
         assert x['provider_principal_loss_entry_value']<=x['debt_entry_value']+1e-8
        be=position(side,c,l)['break_even_price_ratio']
        assert abs(position(side,c,l,be)['user_net_pnl'])<1e-8
    # explicit cash conservation on solvent and insolvent closes
    for r in [.1,1,11]:
      x=position('long',100,2,r,gas=0)
      available=200*(1-F)**2*r/(1+IMPACT)**2
      assert abs(available-x['repaid_units']*ETH_USD-x['user_equity_after_exit'])<1e-8
      x=position('short',100,2,r,gas=0)
      cash=100+200*(1-F)/(1+IMPACT)
      spent=x['repaid_units']*P0*r*(1+IMPACT)/(1-F)
      assert abs(cash-spent-x['user_equity_after_exit'])<1e-8
    assert position('long',ratio=.1)['bad_debt_units']>0
    assert position('short',ratio=11)['bad_debt_units']>0
    for n in [Decimal('0.0000000000000000011'),Decimal('1.2345678901234567899')]:
      scale=Decimal(10)**18
      debt=(n*scale).to_integral_value(rounding=ROUND_CEILING)
      payout=(n*scale).to_integral_value(rounding=ROUND_FLOOR)
      assert payout<=n*scale<=debt and debt-payout<=1
    assert capital(100,2,10,5)['eth_loans_usd']==500
    assert capital(100,2,10,5)['claus_loans']==1000000
    print('PASS: analytical conservation, asset debt repayment, fees, insolvency, break-even and directed rounding')

if __name__=='__main__':
    p=argparse.ArgumentParser(description=__doc__)
    p.add_argument('--self-test',action='store_true')
    args=p.parse_args()
    if args.self_test:self_test()
    else:print(json.dumps(results(),indent=2,allow_nan=False))