this_algorithm/tests/algorithm.rs

use common::test_events;
use s2::cellid::CellID;
use xpin::Error;
use xpin::{Address, CELLID_LEVEL};
#[macro_use]
mod common;
use common::approx_geodetic_difference_m;
use common::ALLOWED_DISTANCE_ERROR_M;
use common::CELLID_LEVEL_23_BITMASK;
use common::CELLID_LEVEL_23_END_BIT;

#[test]
fn test_invalid_lat_lon() {
    assert_eq!(
        Address::from_lat_lon(1.0_f64, 400.0_f64),
        Err(Error::InvalidLatLng)
    );
    assert_eq!(
        Address::from_lat_lon(1.0_f64, f64::NAN),
        Err(Error::InvalidLatLng)
    );
}

#[test]
fn test_decoding_lat_lon() {
    let mut max = f64::MIN;
    let mut min = f64::MAX;
    for (idx, entry) in test_events().iter().enumerate() {
        eprintln!("Testing row {idx}");

        let addr = Address::from_lat_lon(entry.lat, entry.lon).unwrap();
        let addr_latlon = addr.as_lat_lon();

        let (lat_diff, lon_diff) = (
            (entry.lat - addr_latlon.0).abs(),
            (entry.lon - addr_latlon.1).abs(),
        );

        min = if lat_diff < min {
            lat_diff
        } else if lon_diff < min {
            lon_diff
        } else {
            min
        };

        max = if lat_diff > max && lat_diff < 1_f64 {
            lat_diff
        } else if lon_diff > max && lon_diff < 1_f64 {
            lon_diff
        } else {
            max
        };

        if lat_diff > 0.01_f64 || lon_diff > 0.01_f64 {
            eprintln!(
                "Uh oh: {lat_diff}, {lon_diff}, ({}, {}) => ({:?}) => ({:?})",
                entry.lat, entry.lon, addr, addr_latlon
            );
        }

        // Ensure the distance is not more than the allowed distance
        // assert!(
        //     approx_geodetic_difference_m(addr_latlon, (entry.lat, entry.lon))
        //         < ALLOWED_DISTANCE_ERROR_M
        // );

        // assert_eq!((entry.lat, entry.lon), (latlon.0, latlon.1));
    }
    eprintln!("Got max: {max} and min: {min}");
}

#[test]
fn test_cellid_translation() {
    for (idx, entry) in test_events().iter().enumerate() {
        eprintln!("Testing row {idx}");

        let addr = Address::from_lat_lon(entry.lat, entry.lon).unwrap();
        let addr_cellid = addr.as_cellid();

        eprintln!(
            "Entry: ({},{}) => {:0>64b}",
            entry.lat, entry.lon, entry.cellid
        );
        eprintln!("\taddr: {addr}");

        // Make sure the rust s2 implementation is accurate
        assert_eq!(entry.cellid, CellID(entry.cellid).0);
        assert_eq!(
            (entry.cellid & CELLID_LEVEL_23_BITMASK) | CELLID_LEVEL_23_END_BIT,
            CellID(entry.cellid).parent(CELLID_LEVEL).0
        );

        // Make sure the address is at the right level
        assert_eq!(addr_cellid.level(), CELLID_LEVEL);

        // Next, check if creating an address from a cellid matches itself
        assert_eq!(addr, Address::from_cellid_u64(entry.cellid));
        assert_eq!(
            addr_cellid,
            Address::from_cellid_u64(entry.cellid).as_cellid()
        );

        // Now check if the actual cell id matches
        assert_eq_u64!(addr_cellid.0, CellID(entry.cellid).parent(CELLID_LEVEL).0);
    }
}

#[test]
fn test_encoding() {
    for (_idx, entry) in test_events().iter().enumerate() {
        let addr = Address::from_lat_lon(entry.lat, entry.lon).unwrap();
        eprintln!("({}, {}) => {addr}", entry.lat, entry.lon);
    }
    // TODO:
    // assert!(false);
}

#[test]
fn test_decoding() {}