// Возьмём 2 типа - банан и смузи:
struct Banana {
    ripeness: u8,
}

struct Smoothie {
    flavor: String,
}

// Сообщаем как превратить банан в смузи:
impl From<Banana> for Smoothie {
    fn from(banana: Banana) -> Self {
        Smoothie {
            flavor: format!("banana ripeness level {}", banana.ripeness),
        }
    }
}

// Получаем:
let my_banana = Banana { ripeness: 8 };
let my_smoothie: Smoothie = my_banana.into();  // авто конвертация!
// ИЛИ
let my_smoothie = Smoothie::from(my_banana);    // явная конвертация!

let my_string: String = "hello".into();  // &str → String
let owned_string = String::from("hello");

use std::path::PathBuf;
let path: PathBuf = "/home/user/docs".into();  // &str → PathBuf

// Converting different errors into one type
impl From<NetworkError> for AppError {
    fn from(error: NetworkError) -> Self {
        AppError::Network(error.to_string())
    }
}

// Now functions can use ? operator automatically:
fn do_stuff() -> Result<(), AppError> {
    let data = connect_to_server()?;  // NetworkError automatically becomes AppError!
    Ok(())
}

// Anyone with the "Flying" badge must have a method called fly
trait Flying {
    fn fly(&self); // Takes a reference to itself, returns nothing
}

// Trait implementation
// Our hero
struct SuperHero {
    name: String,
}

// Our enemy
struct WickedWitch {
    name: String,
}

// We give both the Flying badge, but they implement it differently
impl Flying for SuperHero {
    fn fly(&self) {
        println!("{} soars through the sky majestically!", self.name);
    }
}

impl Flying for WickedWitch {
    fn fly(&self) {
        println!("{} cackles loudly as her broomstick rattles into the air!", self.name);
    }
}

// ONE function, that works on ANYTHING with the Flying badge:

// This function doesn't care if it's a hero or a witch.
// It just says: "Bring me anything with the 'Flying' badge."
fn race_to_the_castle(flyer: &impl Flying) {
    println!("The race starts!");
    flyer.fly(); // We know it can fly, because it has the badge!
    println!("We made it to the castle!");
}

fn main() {
    let hero = SuperHero { name: String::from("Captain Soar") };
    let witch = WickedWitch { name: String::from("Elvira") };

    // Both work perfectly!
    race_to_the_castle(&hero);
    race_to_the_castle(&witch);
}

// короткий способ, использовался ранее:
fn race_to_the_castle(flyer: &impl Flying) {
    flyer.fly();
}

// Способ turbofish way (полный generic syntax):
fn race_to_the_castle<F: Flying>(flyer: &F) {
    flyer.fly();
}

// SHORTHAND: This allows a Cat and a Dog to be shuffled around
fn shuffle_pair(a: &impl Animal, b: &impl Animal) {
    // 'a' could be a Cat, 'b' could be a Dog
}

// TURBOFISH: This FORCES both to be the same type
fn shuffle_pair<T: Animal>(a: &T, b: &T) {
    // a and b MUST be the same kind of animal
}

fn main() {
    let cat = Cat { name: String::from("Whiskers") };
    let dog = Dog { name: String::from("Rover") };
    
    // Works with shorthand (different types allowed)
    shuffle_pair(&cat, &dog); // OK
    
    // ERROR with turbofish (cat and dog are different types!)
    // shuffle_pair::<Cat>(&cat, &dog); // 💥 Dog ≠ Cat
}

// You put in a specific animal, you get THAT same type back
fn clone_animal<A: Animal + Clone>(original: &A) -> A {
    original.clone() // Returns the same type that went in
}

fn main() {
    let cat = Cat { name: String::from("Whiskers") };
    let cloned_cat = clone_animal(&cat); // We know cloned_cat is a Cat
}

// This thing must be Flying AND have a BattleCry
fn dramatic_entrance<F: Flying + BattleCry>(fighter: &F) {
    fighter.battle_cry();
    fighter.fly();
}

// Define a weapon type
struct Sword {
    damage: u32,
}

struct Wand {
    magic_power: u32,
}

// This trait says "I can hold some type of item W"
// The <W> is a placeholder waiting to be filled
trait CanHold<W> {
    fn hold(&self, item: W);
    fn describe_held_item(&self) -> String;
}

struct Knight {
    name: String,
}

struct Wizard {
    name: String,
}

// The knight can hold a Sword specifically
impl CanHold<Sword> for Knight {
    fn hold(&self, item: Sword) {
        println!("{} grips the sword firmly! Damage: {}", self.name, item.damage);
    }
    
    fn describe_held_item(&self) -> String {
        String::from("A heavy blade")
    }
}

// The wizard can hold a Wand specifically
impl CanHold<Wand> for Wizard {
    fn hold(&self, item: Wand) {
        println!("{} twirls the wand gracefully! Power: {}", self.name, item.magic_power);
    }
    
    fn describe_held_item(&self) -> String {
        String::from("A mystical wand")
    }
}

struct Shield {
    defense: u32,
}

// The knight can ALSO hold a Shield!
impl CanHold<Shield> for Knight {
    fn hold(&self, item: Shield) {
        println!("{} raises the shield! Defense: {}", self.name, item.defense);
    }
    
    fn describe_held_item(&self) -> String {
        String::from("A sturdy shield")
    }
}

fn main() {
    let knight = Knight { name: String::from("Arthur") };
    
    // The same knight can hold different items!
    knight.hold(Sword { damage: 50 });   // Uses CanHold<Sword>
    knight.hold(Shield { defense: 30 }); // Uses CanHold<Shield> - same trait, different weapon!
}

// AsRef is defined like this (simplified):
trait AsRef<T> {
    fn as_ref(&self) -> &T;  // "Turn myself into a reference to T"
}

// String implements AsRef<str> - "I can act as a string slice reference"
impl AsRef<str> for String {
    fn as_ref(&self) -> &str {
        // String can easily give a &str view of its contents
        &self[..]
    }
}

// &str also implements AsRef<str> - "I'm already a str reference!"
impl AsRef<str> for &str {
    fn as_ref(&self) -> &str {
        self  // Just return myself, I'm already what you want
    }
}

// PathBuf (a file path type) implements AsRef<Path>
impl AsRef<Path> for PathBuf {
    fn as_ref(&self) -> &Path {
        // Give a Path view of the PathBuf
        self.as_path()
    }
}

fn hello<N: AsRef<str>>(name: N) {
    println!("Hello, {}!", name.as_ref());
}

struct Player {
    name: String,
}

struct Dragon {
    fire_power: u32,
}

struct Rabbit {
    speed: u32,
}

// The polymorph trait: "I can transform into T"
trait Polymorph<T> {
    fn transform(&self) -> T;
}

// Player can polymorph into a Dragon
impl Polymorph<Dragon> for Player {
    fn transform(&self) -> Dragon {
        println!("{} grows scales and wings!", self.name);
        Dragon { fire_power: 100 }
    }
}

// Player can ALSO polymorph into a Rabbit
impl Polymorph<Rabbit> for Player {
    fn transform(&self) -> Rabbit {
        println!("{} shrinks and grows fluffy ears!", self.name);
        Rabbit { speed: 200 }
    }
}

fn main() {
    let player = Player { name: String::from("Alex") };
    
    // Same player, same trait name, completely different transformations!
    let dragon_form = player.transform(); // Rust infers we want Dragon here
    let rabbit_form: Rabbit = player.transform(); // Explicitly ask for Rabbit
}