use bitfield_struct::bitfield;

/// 定义一个8位的结构体
#[bitfield(u8)]
struct MyByte {
    /// 占用最低的4位
    #[bits(4)]
    kind: usize,
    /// 占用1位，自动映射为bool
    system: bool,
    /// 占用2位
    #[bits(2)]
    level: usize,
    /// 占用最高的1位
    present: bool,
}

fn main() {
    // 使用链式调用的构造器创建实例
    let my_byte = MyByte::new()
        .with_kind(15)
        .with_system(false)
        .with_level(3)
        .with_present(true);

    // 通过生成的getter读取
    assert!(my_byte.present());
    assert_eq!(my_byte.kind(), 15);
}

#[bitfield(u16)]
struct MyBitfield {
    #[bits(16)]
    custom: CustomEnum,
}

#[derive(Debug, PartialEq, Eq)]
#[repr(u16)]
enum CustomEnum {
    A = 0,
    B = 1,
    C = 2,
}

impl CustomEnum {
    const fn into_bits(self) -> u16 {
        self as u16
    }
    const fn from_bits(value: u16) -> Self {
        match value {
            0 => Self::A,
            1 => Self::B,
            _ => Self::C,
        }
    }
}

#[bitfield(u32)]
struct Advanced {
    /// 只读字段（仅生成getter）
    #[bits(8, access = RO)]
    read_only: u8,
    /// 只写字段（仅生成setter）
    #[bits(8, access = WO)]
    write_only: u8,
}

// 指定MSB（最高有效位）优先的位序
#[bitfield(u8, order = Msb)]
struct MsbByte {
    #[bits(4)]
    high_nibble: u8,
    #[bits(4)]
    low_nibble: u8,
}

use bilge::prelude::*;

// 1. 定义一个嵌套结构体 Footer，占2位
#[bitsize(2)]
#[derive(FromBits)]
struct Footer {
    flag: bool,
    code: Code,
}

// 2. 定义一个枚举，占1位
#[bitsize(1)]
#[derive(Debug, PartialEq)]
enum Code {
    Success,
    Error,
}

// 3. 定义主寄存器，共14位
#[bitsize(14)]
#[derive(FromBits, DebugBits)]
struct Register {
    header: u4,
    data: u6,
    footer: Footer,
    reserved: u2,
}

fn main() {
    // 方式一：通过 new() 构造
    let reg1 = Register::new(
        u4::new(0b1010),
        u6::new(0b111111),
        Footer::new(false, Code::Success),
        u2::new(0),
    );

    // 方式二：从原始值解析
    let mut reg2 = Register::from(u14::new(0b11_1_0101010_1010));
    
    // 读取和修改字段
    let header = reg2.header();  // 返回 u4 类型
    reg2.set_footer(Footer::new(true, Code::Error));
    
    // 调试输出
    println!("{:?}", reg2);
    // 输出: Ok(Register { header: 10, data: 42, footer: Footer { flag: true, code: Error }, reserved: 0 })
}

#[bitsize(2)]
#[derive(Debug, PartialEq)]
enum DeviceClass {
    Storage = 0,
    Network = 1,
    Display = 2,
    // 值3未定义，TryFrom 会返回错误
}

#[bitsize(8)]
#[derive(FromBits, DebugBits)]
struct Device {
    class: DeviceClass,
    reserved: u6,
}

// TryFrom 自动传播
let device = Device::try_from(u8::new(0b00_000010));
assert_eq!(device.unwrap().class(), DeviceClass::Storage);

use fray::{bitfield, BitField};

#[bitfield(repr(u8), impls(debug), derives(Clone, Copy))]
pub struct DeviceFlags {
    powered_on: bool,
    error: bool,
    tx_enabled: bool,
    rx_enabled: bool,
    #[bits(3)]      // 覆盖默认大小
    priority: u8,
    #[bits(1)]
    reserved: (),
}

fn main() {
    let mut flags = DeviceFlags::new();
    
    // 通过泛型方法读写字段
    flags.with::<powered_on>(true)
         .with::<tx_enabled>(true)
         .with::<priority>(5);
    
    assert!(flags.get::<powered_on>());
    assert_eq!(flags.get::<priority>(), 5);
    
    flags.set::<error>(true);
    assert!(flags.get::<error>());
    
    // 转为原始值
    assert_eq!(flags.into_inner(), 0b0_101_0_1_1_1);
    //                    |   |   | | | |
    //                    |   |   | | | powered_on
    //                    |   |   | | error
    //                    |   |   | tx_enabled
    //                    |   |   rx_enabled
    //                    |   priority
    //                    reserved
}