use heromodels::db::hero::OurDB;
use heromodels::db::{Collection, Db};
use heromodels::models::finance::account::Account;
use heromodels::models::finance::asset::{Asset, AssetType};
use heromodels::models::finance::marketplace::{Listing, ListingType};
use heromodels_core::Model;
use std::sync::Arc;

/// Seed the mock database with finance data
pub fn seed_finance_data(db: Arc<OurDB>) {
    // Create a user account
    let account = Account::new()
        .name("Demo Account")
        .user_id(1)
        .description("Demo trading account")
        .ledger("ethereum")
        .address("0x1234567890abcdef1234567890abcdef12345678")
        .pubkey("0xabcdef1234567890abcdef1234567890abcdef12");

    // Store the account in the database
    let (account_id, mut updated_account) = db
        .collection::<Account>()
        .expect("Failed to get Account collection")
        .set(&account)
        .expect("Failed to store account");

    // Create an ERC20 token asset
    let token_asset = Asset::new()
        .name("HERO Token")
        .description("Herocode governance token")
        .amount(1000.0)
        .address("0x9876543210abcdef9876543210abcdef98765432")
        .asset_type(AssetType::Erc20)
        .decimals(18);

    // Store the token asset in the database
    let (token_id, updated_token) = db
        .collection::<Asset>()
        .expect("Failed to get Asset collection")
        .set(&token_asset)
        .expect("Failed to store token asset");

    // Create an NFT asset
    let nft_asset = Asset::new()
        .name("Herocode #1")
        .description("Unique digital collectible")
        .amount(1.0)
        .address("0xabcdef1234567890abcdef1234567890abcdef12")
        .asset_type(AssetType::Erc721)
        .decimals(0);

    // Store the NFT asset in the database
    let (nft_id, updated_nft) = db
        .collection::<Asset>()
        .expect("Failed to get Asset collection")
        .set(&nft_asset)
        .expect("Failed to store NFT asset");

    // Add assets to the account
    updated_account = updated_account.add_asset(token_id);
    updated_account = updated_account.add_asset(nft_id);

    // Update the account in the database
    let (_, final_account) = db
        .collection::<Account>()
        .expect("Failed to get Account collection")
        .set(&updated_account)
        .expect("Failed to store updated account");

    // Create a listing for the NFT
    let listing = Listing::new()
        .seller_id(account_id)
        .asset_id(nft_id)
        .price(0.5)
        .currency("ETH")
        .listing_type(ListingType::Auction)
        .title("Rare Herocode NFT".to_string())
        .description("One of a kind digital collectible".to_string())
        .image_url(Some("https://example.com/nft/1.png".to_string()))
        .add_tag("rare".to_string())
        .add_tag("collectible".to_string());

    // Store the listing in the database
    let (_listing_id, updated_listing) = db
        .collection::<Listing>()
        .expect("Failed to get Listing collection")
        .set(&listing)
        .expect("Failed to store listing");

    println!("Mock database seeded with finance data:");
    println!(
        "  - Added account: {} (ID: {})",
        final_account.name,
        final_account.get_id()
    );
    println!(
        "  - Added token asset: {} (ID: {})",
        updated_token.name,
        updated_token.get_id()
    );
    println!(
        "  - Added NFT asset: {} (ID: {})",
        updated_nft.name,
        updated_nft.get_id()
    );
    println!(
        "  - Added listing: {} (ID: {})",
        updated_listing.title,
        updated_listing.get_id()
    );
}