#![allow(unused)]

use std::fs::File;
use std::io;
use std::process::ExitCode;

// -----------------------------------
use std::convert::From;

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::Error1
    }
}
// -----------------------------------

const FN: &str = "DATEI GIBTS NICHT";

#[derive(Debug)]
enum MyError {
    Error1,
    Error2 { msg: String },
    Error3,
}

fn f1() -> Result<(), MyError> {
    println!("f1()");
    Err(MyError::Error1)
}

fn f2() -> Result<(), MyError> {
    println!("f2()");

    // Im Ok Fall ist res vom Typ
    //    Ok(File { fd: 3, path: "README.md", read: true, write: false })
    // Falls Datei nicht existiert ist res vom Typ
    //    Err(Os { code: 2, kind: NotFound, message: "No such file or directory" })
    let res = File::open(FN); // Result<File, std::io::Error>
    println!("res = {res:?}");
    if let Err(e) = res {
        println!("kind = {}", e.kind()); // "entity not found"
        println!("code = {:?}", e.raw_os_error()); // Some(2)
        println!("msg = {:?}", e.to_string());
    }

    println!("<1>");

    // .map_err() ...
    // std::io::Error -> MyError
    /*
    let res = File::open(FN).map_err(|e| MyError::Error2 { msg: e.to_string() })?;
    */

    println!("<2>");

    // oder From Trait implementieren fuer MyError und ?-Op
    let res = File::open(FN)?;

    println!("<3>");

    Ok(())
}

fn main() -> ExitCode {
    let e = f1();
    println!("f1 returns {:?}", e);

    let e = f2();
    println!("f2 returns {:?}", e);

    let ok = true;
    if ok {
        ExitCode::SUCCESS
    } else {
        ExitCode::FAILURE
    }
}