use cached::proc_macro::cached;

#[cached(name = "FIB")]
fn fib(n: u64) -> u64 {
    if n == 0 || n == 1 {
        return n;
    }
    fib(n - 1) + fib(n - 2)
}

fn main() {
    println!("{}", { fib(30) });
}

use tracing::{debug, error, info, warn};
use tracing_appender::rolling;
use tracing_subscriber::fmt;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;

fn main() {
    tracing_subscriber::registry()
        .with(fmt::layer().with_writer(std::io::stdout).with_ansi(true))
        .with(
            fmt::layer()
                .with_writer(rolling::daily("./logs", "app.log"))
                .with_ansi(false),
        )
        .init();

    debug!("这是 Debug 日志");
    info!("这是 Info 日志");
    warn!("这是 Warn 日志");
    error!("这是 Error 日志");
}

use std::ops::{Add, Sub};

#[derive(Debug)]
struct Complex<T> {
    r: T,
    i: T,
}

impl<T: Add<Output = T>> Add for Complex<T> {
    type Output = Complex<T>;

    fn add(self, rhs: Self) -> Self {
        Self {
            r: self.r + rhs.r,
            i: self.i + rhs.i,
        }
    }
}

impl<T: Sub<Output = T>> Sub for Complex<T> {
    type Output = Complex<T>;

    fn sub(self, rhs: Self) -> Self {
        Self {
            r: self.r - rhs.r,
            i: self.i - rhs.i,
        }
    }
}

fn main() {
    let a = Complex { r: 1, i: 2 };
    let b = Complex { r: 3, i: 4 };
    let c = Complex { r: 5, i: 6 };
    println!("{:?}", a + b - c);
}

use std::collections::VecDeque;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll, Waker};
use std::time::{Duration, Instant};


trait Task {
    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<()>;
}

impl<F: Future> Task for F {
    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<()> {
        match self.poll(context) {
            Poll::Ready(_) => Poll::Ready(()),
            Poll::Pending => Poll::Pending,
        }
    }
}

struct Executor {
    tasks: VecDeque<Pin<Box<dyn Task>>>,
}

impl Executor {
    fn new() -> Self {
        Self {
            tasks: VecDeque::new(),
        }
    }

    fn spawn(&mut self, task: impl Task + 'static) {
        self.tasks.push_back(Box::pin(task));
    }

    fn run(&mut self) {
        loop {
            let mut task = if let Some(task) = self.tasks.pop_front() {
                task
            } else {
                break;
            };

            let mut context = Context::from_waker(Waker::noop());
            match task.as_mut().poll(&mut context) {
                Poll::Ready(()) => {
                    continue;
                }
                Poll::Pending => {
                    self.tasks.push_back(task);
                }
            }

            std::thread::sleep(Duration::from_millis(20));
        }
    }
}

struct Sleep {
    deadline: Instant,
}

impl Sleep {
    fn sleep(sconds: f32) -> Self {
        Self {
            deadline: Instant::now() + Duration::from_secs_f32(sconds),
        }
    }
}

impl Future for Sleep {
    type Output = ();

    fn poll(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Self::Output> {
        if Instant::now() >= self.deadline {
            Poll::Ready(())
        } else {
            Poll::Pending
        }
    }
}

async fn async_main() {
    Sleep::sleep(3.0).await;
    println!("DONE")
}

fn main() {
    let mut executor = Executor::new();
    executor.spawn(async_main());
    executor.spawn(async_main());
    executor.spawn(async_main());
    executor.spawn(async_main());
    executor.run();
}

#![no_std]
#![no_main]

core::arch::global_asm!(
    ".globl _start",
    "_start:",
    "mov rax, 1",                // syscall: write
    "mov rdi, 1",                // fd: stdout
    "lea rsi, [rip + msg]",      // buffer地址
    "mov rdx, 11",               // 字符串长度
    "syscall",
    "mov rax, 60",               // syscall: exit
    "xor rdi, rdi",              // status: 0
    "syscall",
    "msg:",
    ".ascii \"hello,world\""
);

#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! { loop {} }

trait Shape {
    fn area(&self) -> f64;
}

struct Square {
    size: f64,
}

impl Square {
    pub fn new(size: f64) -> Square {
        Square { size }
    }
}

impl Shape for Square {
    fn area(&self) -> f64 {
        self.size * self.size
    }
}

struct Circle {
    radius: f64,
}

impl Circle {
    pub fn new(radius: f64) -> Circle {
        Circle { radius }
    }
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

fn area(shape: &dyn Shape) -> f64 {
    shape.area()
}

fn main() {
    let square = Square::new(3.0);
    let circle = Circle::new(3.0);

    println!("square: {}", area(&square));
    println!("circle: {}", area(&circle));
}

#![no_std]
#![no_main]

unsafe extern "C" {
    fn write(fd: i32, buf: *const u8, count: usize) -> isize;
    fn exit(status: i32) -> !;
}

#[panic_handler]
unsafe fn panic(_info: &core::panic::PanicInfo) -> ! {
    exit(-1);
}

#[no_mangle]
unsafe extern "C" fn _start() -> ! {
    let msg = b"hello, world!\n";
    write(1, msg.as_ptr(), msg.len());
    exit(0);        
}