orthodoxy 0.2.4

use std::collections::HashMap;

use facet::{Def, EnumType, Facet, StructKind, StructType, Type, UnionType, UserType};
use tracing::warn;

/// Only makes sense for structs and enums
pub trait Transform<'a, A: Facet<'a>, B: Facet<'a>> {
    fn a_to_b(&self, a: A) -> B;

    fn test_diff(&self) {
        let a_def = A::SHAPE.def;
        let b_def = B::SHAPE.def;

        if let (Type::User(a_type), Type::User(b_type)) = (A::SHAPE.ty, B::SHAPE.ty) {
            match (a_type, b_type) {
                (UserType::Struct(a), UserType::Struct(b)) => struct2(a, b),
                (UserType::Enum(a), UserType::Enum(b)) => enum2(a, b),
                (UserType::Union(a), UserType::Union(b)) => union2(a, b),
                _ => {
                    warn!("A and B need to be the same kind of object")
                }
            }
        } else {
            warn!("A and B need to both be UserTypes")
        }
    }
}

fn struct2(a: StructType, b: StructType) {
    match (a.kind, b.kind) {
        (StructKind::Unit, _) | (_, StructKind::Unit) => {}
        (StructKind::TupleStruct, StructKind::TupleStruct) => {}
        (StructKind::Struct, StructKind::Struct) => {}
        (StructKind::Tuple, StructKind::Tuple) => {}
        _ => {}
    }
    let larger = if (a.fields.len() >= b.fields.len()) {
        a.fields.len()
    } else {
        b.fields.len()
    };

    let mut field_map: HashMap<String, String> = HashMap::with_capacity(larger);
    todo!()
}

fn enum2(a: EnumType, b: EnumType) {}

fn union2(a: UnionType, b: UnionType) {}

/// Requires:
/// old_name exists on A
/// new_name exists on B
/// old_name and new_name have the identical type
struct Renamed {
    old_field_name: String,
    new_field_name: String,
}
struct Removed {
    field_name: String,
}
struct Retyped {
    field_name: String,
    old_type: String,
    new_type: String,
}

pub struct AddField<T> {
    name: String,
    default: T,
}