use serde_json;

use heromodels::models::grid4::{
    ComputeSlice, DeviceInfo, Node, NodeCapacity, PricingPolicy, Reservation, ReservationStatus,
    SLAPolicy, StorageDevice, StorageSlice,
};

#[test]
fn build_and_serde_roundtrip_compute_storage_slices() {
    let pricing = PricingPolicy::new()
        .marketplace_year_discounts(vec![20, 30, 40])
        .volume_discounts(vec![5, 10, 15])
        .build();

    let sla = SLAPolicy::new()
        .sla_uptime(99)
        .sla_bandwidth_mbit(1000)
        .sla_penalty(150)
        .build();

    let cs = ComputeSlice::new()
        .nodeid(42)
        .slice_id(1)
        .mem_gb(16.0)
        .storage_gb(200.0)
        .passmark(5000)
        .vcores(8)
        .cpu_oversubscription(2)
        .storage_oversubscription(1)
        .price_range(vec![0.5, 2.0])
        .gpus(1)
        .price_cc(1.25)
        .pricing_policy(pricing.clone())
        .sla_policy(sla.clone());

    let ss = StorageSlice::new()
        .nodeid(42)
        .slice_id(2)
        .price_cc(0.15)
        .pricing_policy(pricing)
        .sla_policy(sla);

    // serde roundtrip compute slice
    let s = serde_json::to_string(&cs).expect("serialize compute slice");
    let cs2: ComputeSlice = serde_json::from_str(&s).expect("deserialize compute slice");
    assert_eq!(cs, cs2);

    // serde roundtrip storage slice
    let s2 = serde_json::to_string(&ss).expect("serialize storage slice");
    let ss2: StorageSlice = serde_json::from_str(&s2).expect("deserialize storage slice");
    assert_eq!(ss, ss2);
}

#[test]
fn build_and_serde_roundtrip_node() {
    let dev = DeviceInfo {
        vendor: "AcmeVendor".into(),
        storage: vec![StorageDevice { id: "sda".into(), size_gb: 512.0, description: "NVMe".into() }],
        memory: vec![],
        cpu: vec![],
        gpu: vec![],
        network: vec![],
    };

    let cap = NodeCapacity { storage_gb: 2048.0, mem_gb: 128.0, mem_gb_gpu: 24.0, passmark: 12000, vcores: 32 };

    let cs = ComputeSlice::new().nodeid(1).slice_id(1).mem_gb(8.0).storage_gb(100.0).passmark(2500).vcores(4);
    let ss = StorageSlice::new().nodeid(1).slice_id(2).price_cc(0.2);

    let node = Node::new()
        .nodegroupid(7)
        .uptime(99)
        .add_compute_slice(cs)
        .add_storage_slice(ss)
        .devices(dev)
        .country("NL")
        .capacity(cap)
        .provisiontime(1710000000)
        .pubkey("node_pubkey")
        .signature_node("sig_node")
        .signature_farmer("sig_farmer");

    let s = serde_json::to_string(&node).expect("serialize node");
    let node2: Node = serde_json::from_str(&s).expect("deserialize node");

    assert_eq!(node.nodegroupid, node2.nodegroupid);
    assert_eq!(node.uptime, node2.uptime);
    assert_eq!(node.country, node2.country);
    assert_eq!(node.pubkey, node2.pubkey);
    assert_eq!(node.signature_node, node2.signature_node);
    assert_eq!(node.signature_farmer, node2.signature_farmer);
    assert_eq!(node.computeslices.len(), node2.computeslices.len());
    assert_eq!(node.storageslices.len(), node2.storageslices.len());
}

#[test]
fn build_and_serde_roundtrip_reservation() {
    let reservation = Reservation::new()
        .customer_id(1234)
        .add_compute_slice(11)
        .add_storage_slice(22)
        .status(ReservationStatus::Confirmed)
        .obligation(true)
        .start_date(1_710_000_000)
        .end_date(1_720_000_000);

    let s = serde_json::to_string(&reservation).expect("serialize reservation");
    let reservation2: Reservation = serde_json::from_str(&s).expect("deserialize reservation");

    assert_eq!(reservation.customer_id, reservation2.customer_id);
    assert_eq!(reservation.status, reservation2.status);
    assert_eq!(reservation.obligation, reservation2.obligation);
    assert_eq!(reservation.start_date, reservation2.start_date);
    assert_eq!(reservation.end_date, reservation2.end_date);
    assert_eq!(reservation.compute_slices, reservation2.compute_slices);
    assert_eq!(reservation.storage_slices, reservation2.storage_slices);
}