use windows::Win32::UI::WindowsAndMessaging::{MessageBoxA, MB_OK};
use encoding_rs::*;


fn main( )->windows::core::Result<()>{

  // windows::core::s! マクロ ... 文字列(utf8)をLPCSTR へ変換。
  // MessageBoxWを使う場合はLPCWSTR へ変換するw!を使用。

  unsafe {

    // windows::core::s!() にそのまま日本語を与えると文字化けする。
    // Rustはu8が基本。 MessageBoxA はnull終端のマルチバイト(ShiftJIS)なので、変換が必要
    let msg = SHIFT_JIS.encode("ハローワールド");
    let ttl = SHIFT_JIS.encode("タイトル");

    let mut msg0 = msg.0.to_vec();
    let mut ttl0 = ttl.0.to_vec();

    // null 終端にする
    msg0.push(0);
    ttl0.push(0);

    let smsg0 = windows::core::PCSTR(msg0.as_ptr());
    let sttl0 = windows::core::PCSTR(ttl0.as_ptr());
    MessageBoxA(
      None,
      smsg0, 
      sttl0,
       MB_OK
    );
  }

  Ok(())

}

#include <iostream>

//https://tclap.sourceforge.net/

#include <tclap/CmdLine.h>

int main(int argc, char** argv) {
  int val_int;
  std::string val_string;

  // Define the command line object
  TCLAP::CmdLine cmd(
    "test program"    // アプリケーションの説明
    , ' '             // コマンドライン引数の区切り文字
    , "0.1"           // ツールのバージョン
    , true            // -hで表示されるヘルプを作成する
  );

  TCLAP::ValueArg<int> arg_i(
      "n"                           // 引数指定方法 -n 123 のように記述
    , "number"                      // 引数指定方法 --number のように記述
    , "count of data"               // ヘルプに表示する説明
    , true                          // 必須項目であることを示す
    , 0                             // 初期値
    , "integer"                     // ヘルプに表示するこのオプションのデータ型
  );
  cmd.add(arg_i);

  TCLAP::ValueArg<std::string> arg_s(
      "t"                           // 引数指定方法 -t abc のように記述
    , "text"                        // 引数指定方法 --text のように記述
    , "text data"                   // ヘルプに表示する説明
    , false                         // 必須項目であることを示す
    , "void"                        // 初期値
    , "text"                     // ヘルプに表示するこのオプションのデータ型
  );
  cmd.add(arg_s);

  // コマンドライン引数を解釈する
  cmd.parse(argc, argv);

  // 解釈した値を取得する
  val_int = arg_i.getValue();
  val_string = arg_s.getValue();

  // 入力されたオプションを確認
  std::cout << "input : " << val_int << std::endl;
  std::cout << "input : " << val_string << std::endl;

  return 0;
}

use windows::Win32::UI::WindowsAndMessaging::{MessageBoxW, MB_OK};


fn main( )->windows::core::Result<()>{

  // windows::core::s! マクロ ... 文字列(utf8)をLPCSTR へ変換。
  // MessageBoxWを使う場合はLPCWSTR へ変換するw!を使用。

  unsafe {
    MessageBoxW(
      None,
      windows::core::w!("ハローワールド"), 
      windows::core::w!("タイトル"),
       MB_OK
    );

  }

  Ok(())

}

// main.rs  エントリポイントのあるファイル

// mod ファイル名
mod myfile;

// use ファイル名::関数名（など）
use myfile::myfunction; // 使いたいものだけ ファイル名::シンボル
use myfile::myparam;    // use myfile::*; も可能


fn main() {

    let ab:myparam = myparam{a:1,b:2.0};

    myfunction(&ab);

}

// myfile.rs 分離したファイル  

// 関数の先頭にpubをつける
pub fn myfunction(ab : &myparam){

    println!("{} {}",ab.a,ab.b);

}

// 構造体の先頭にpubをつける
pub struct myparam{
    pub a:i32, // メンバにも pub をつける
    pub b:f32,
}

// main.rs

// mod ファイル名
mod sibling_1st;

fn main() {

    sibling_1st::fnc_1st();

}

// sibling_1st.rs

#[path = "./sibling_2nd.rs"]
mod sibling_2nd;

pub fn fnc_1st(){

    sibling_2nd::fnc_2nd();

}

// sibling_2nd.rs

pub fn fnc_2nd(){

    println!("my3rd!!!");

}

// stc/main.rs

// mod ファイル名
// 同名のディレクトリを同じ位置に存在させている
mod mydir;

fn main() {

    mydir::sub_1st::fnc_1st();

}

// stc/mydir.rs

pub mod sub_1st;
pub mod sub_2nd;

// src/mydir/sub_1st.rs

#[path = "./sub_2nd.rs"]
mod sub_2nd;

pub fn fnc_1st(){

    sub_2nd::fnc_2nd();

}

// src/mydir/sub_2nd.rs

pub fn fnc_2nd(){

    println!("fnc_2nd called");

}

struct structAB {
  v:i32,
}


fn main() {

    let mut oo=structAB{v:5};

    let _r:&mut structAB = &mut oo; // OK
    let _g:&mut structAB = &mut oo; // NG 可変の参照。二つ目以降は作れない
    let _b:&mut structAB = &mut oo; // NG 

    _r.v=2;
    _g.v=1; // NG そもそも定義できない
    _b.v=0; // NG そもそも定義できない


}

struct structAB {
  v:i32,
}


fn main() {

    let mut oo=structAB{v:5};

    let _r:&structAB = &oo; // OK
    let _g:&structAB = &oo; // OK &mut でなければいくつでも作れる
    let _b:&structAB = &oo; // OK 

    let r = _r.v; // OK 読み取りはできる
    let g = _g.v; // ただし 書き換えられない。
    let b = _b.v; // 

}

#include <iostream>
#include <memory>

struct StructAB {
    int v;
    StructAB(int a) :v(a) {}
};

int main()
{
    auto oo = std::make_shared<StructAB>(5);

    // C++ では所有権を持たない参照をいくつでも参照を作れる
    std::weak_ptr<StructAB> _r = oo;
    std::weak_ptr<StructAB> _g = oo; // Rustではエラー
    std::weak_ptr<StructAB> _b = oo; // 二つ目以降の可変な参照を作れない

    _r.lock()->v = 2;
    _g.lock()->v = 1; // Rustではエラー
    _b.lock()->v = 0; // Rustではエラー

}

struct structAB {
  v:i32,
}

fn main() {

    let oo=structAB{v:5};

    let pp = oo; // ただの=がmoveになる
    
    println!("{} => {}",oo.v , pp.v);// value borrowed here after move 　（ooが無効）

}

#include <iostream>
#include <memory>

struct StructAB {
    int v;
    StructAB(int a) :v(a) {}
};

int main()
{
    auto oo = std::make_unique<StructAB>(5);

    auto pp = std::move(oo); // ここでmoveすると以降ooはnullptr

    printf("%d => %d\n", oo->v,pp->v); // ランタイムエラー （ooがnullptr）

}

struct structAB {
  v:i32,
}

fn test(ii:structAB)->i32{
  
  return ii.v*2;

  // ii はここで解放される
}

fn main() {

    let oo=structAB{v:5};

    let pp = test(oo); // ここで oo がmoveされてしまうので、test関数から抜けた段階でライフタイムが切れる

    println!("{} => {}",oo.v , pp);

}

#include <iostream>
#include <memory>

struct StructAB {
    int v;
    StructAB(int a) :v(a) {}
};

int test(std::unique_ptr<StructAB> ii) {
    
    return ii->v * 2;

    // ii はここでデストラクトされる
}

int main()
{
    auto oo = std::make_unique<StructAB>(5);

    auto pp = test(std::move(oo)); // ここでmoveすると以降ooはnullptr

    printf("%d => %d\n", oo->v,pp);

}

struct structAB {
  v:i32,
}

fn test(jj:&structAB,kk:&structAB )->&structAB{ // error[E0106]: missing lifetime specifier

    let val = getinput();// 入力によってどちらが帰るかが決まる

    if val%2==0{
        return jj;
    }
    else{
        return kk;
    }

}

fn main() {

    let oo=structAB{v:5};

    let _r;
    {
        let vv=structAB{v:4};

        _r = test(&oo,&vv);// _r のライフタイムが oo か vv かわからない

    }

    println!("result: {}",_r.v);
}

      
fn getinput()->i32{
    let mut buffer = String::new();   
    let ret = std::io::stdin().read_line(&mut buffer);
    let val:i32=buffer.trim().parse().unwrap();

    return val;

}

struct structAB {
  v:i32,
}