use crate::events::registry::types::RegistryEvent;
use crate::events::secondary_market::types::SecondaryMarketEvent;
use crate::events::primary_market::types::PrimaryMarketEvent; 
use crate::registry::event_handlers as registry_handlers;
use crate::primary_market::event_handlers as primary_handlers;  // UNCOMMENT WHEN HANDLERS ARE READY
use crate::secondary_market::event_handlers as market_handlers;
use crate::state::AppState;

//FIX: there should be uniform eror handling in the router
//right now i dont like how we have implemented this

pub async fn route_registry_event(event: RegistryEvent) {
    match event {
        RegistryEvent::RegistryInitialized(e) => {
            registry_handlers::handle_registry_initialized(e).await;
        }
        RegistryEvent::LocalAdminRegistered(e) => {
            registry_handlers::handle_local_admin_registered(e).await;
        }
        RegistryEvent::CompanyRegistered(e) => {
            registry_handlers::handle_company_registered(e).await;
        }
        RegistryEvent::EuaMintedToVault(e) => {
            registry_handlers::handle_eua_minted(e).await;
        }
        RegistryEvent::GhgMintedToVault(e) => {
            registry_handlers::handle_ghg_minted(e).await;
        }
        RegistryEvent::EuaTransferredBetweenVaults(e) => {
            registry_handlers::handle_eua_transferred(e).await;
        }
        RegistryEvent::CompanyStatusUpdated(e) => {
            registry_handlers::handle_company_status_updated(e).await;
        }
        RegistryEvent::LocalAdminStatusUpdated(e) => {
            registry_handlers::handle_local_admin_status_updated(e).await;
        }
    }
}

pub async fn route_secondary_market_event(
    event: SecondaryMarketEvent,
    state: AppState,
    market_pubkey: String,
) {
    match event {
        SecondaryMarketEvent::MarketInitialized(e) => {
            println!("🏪 Market Initialized: {:?}", e);
            println!("   Market: {}", e.market);
            println!("   Admin: {}", e.admin);
            println!("   Lot Size: {}", e.lot_size);
            println!("   Tick Size: {}", e.tick_size);
            // no db interaction needed - we just log the event
        }
        SecondaryMarketEvent::UsdcDeposited(e) => {
            if let Err(err) = market_handlers::handle_usdc_deposited(e, state).await {
                eprintln!("❌ Error handling USDC deposit: {}", err);
            }
        }
        SecondaryMarketEvent::UsdcWithdrawn(e) => {
            if let Err(err) = market_handlers::handle_usdc_withdrawn(e, state).await {
                eprintln!("❌ Error handling USDC withdrawal: {}", err);
            }
        }
        SecondaryMarketEvent::OrderPlaced(e) => {
            if let Err(err) = market_handlers::handle_order_placed(e, state, market_pubkey).await {
                eprintln!("❌ Error handling order placement: {}", err);
            }
        }
        SecondaryMarketEvent::TradeExecuted(e) => {
            if let Err(err) = market_handlers::handle_trade_executed(e, state).await {
                eprintln!("❌ Error handling trade execution: {}", err);
            }
        }
        SecondaryMarketEvent::OrderCancelled(e) => {
            if let Err(err) = market_handlers::handle_order_cancelled(e, state).await {
                eprintln!("❌ Error handling order cancellation: {}", err);
            }
        }
    }
}

pub async fn route_primary_market_event(event: PrimaryMarketEvent, state: AppState) {
    match event {
        PrimaryMarketEvent::PrimaryMarketInitialized(e) => {
            primary_handlers::handle_primary_market_initialized(e).await;
        }
        PrimaryMarketEvent::VerifyingKeyInitialized(e) => {
            primary_handlers::handle_verifying_key_initialized(e).await;
        }
        PrimaryMarketEvent::AuctionPublished(e) => {
            if let Err(err) = primary_handlers::handle_auction_published(e, state).await {
                eprintln!("❌ Error handling auction published: {}", err);
            }
        }
        PrimaryMarketEvent::AuctionStarted(e) => {
            println!("🚀 Auction Started: {:?}", e);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Local Admin: {}", e.local_admin);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_auction_started(e, state).await {
            //     eprintln!("❌ Error handling auction started: {}", err);
            // }
        }
        PrimaryMarketEvent::AuctionClosed(e) => {
            println!("🔒 Auction Closed: {:?}", e);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Local Admin: {}", e.local_admin);
            println!("   Total Bids: {}", e.total_bids);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_auction_closed(e, state).await {
            //     eprintln!("❌ Error handling auction closed: {}", err);
            // }
        }
        PrimaryMarketEvent::AuctionCompleted(e) => {
            println!("✅ Auction Completed: {:?}", e);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Local Admin: {}", e.local_admin);
            println!("   Clearing Price: {}", e.clearing_price);
            println!("   Total Bids: {}", e.total_bids);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_auction_completed(e, state).await {
            //     eprintln!("❌ Error handling auction completed: {}", err);
            // }
        }
        PrimaryMarketEvent::AuctionCanceled(e) => {
            println!("❌ Auction Canceled: {:?}", e);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Local Admin: {}", e.local_admin);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_auction_canceled(e, state).await {
            //     eprintln!("❌ Error handling auction canceled: {}", err);
            // }
        }
        PrimaryMarketEvent::CompanyJoinedAuction(e) => {
            println!("🎫 Company Joined Auction: {:?}", e);
            println!("   Company: {}", e.company);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_company_joined_auction(e, state).await {
            //     eprintln!("❌ Error handling company joined auction: {}", err);
            // }
        }
        PrimaryMarketEvent::CompanyLeftAuction(e) => {
            println!("🚪 Company Left Auction: {:?}", e);
            println!("   Company: {}", e.company);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_company_left_auction(e, state).await {
            //     eprintln!("❌ Error handling company left auction: {}", err);
            // }
        }
        PrimaryMarketEvent::BidPlaced(e) => {
            println!("💰 Bid Placed: {:?}", e);
            println!("   Bid Record: {}", e.bid_record);
            println!("   Bid ID: {}", e.bid_id);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Company: {}", e.company);
            println!("   Bid Hash: {:?}", e.bid_hash);
            println!("   Timestamp: {}", e.timestamp);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_bid_placed(e, state).await {
            //     eprintln!("❌ Error handling bid placed: {}", err);
            // }
        }
        PrimaryMarketEvent::BidCanceled(e) => {
            println!("🚫 Bid Canceled: {:?}", e);
            println!("   Bid Record: {}", e.bid_record);
            println!("   Bid ID: {}", e.bid_id);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Company: {}", e.company);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_bid_canceled(e, state).await {
            //     eprintln!("❌ Error handling bid canceled: {}", err);
            // }
        }
        PrimaryMarketEvent::AuctionSettled(e) => {
            println!("🎯 Auction Settled: {:?}", e);
            println!("   Auction: {}", e.auction);
            println!("   Auction ID: {}", e.auction_id);
            println!("   Company: {}", e.company);
            println!("   Bid Record: {}", e.bid_record);
            println!("   Clearing Price: {}", e.clearing_price);
            println!("   EUA Allocated: {}", e.eua_allocated);
            println!("   USDC Paid: {}", e.usdc_paid);
            println!("   Refund: {}", e.refund);
            // Uncomment when handler is implemented:
            // if let Err(err) = primary_handlers::handle_auction_settled(e, state).await {
            //     eprintln!("❌ Error handling auction settled: {}", err);
            // }
        }
    }
}