use shared::datatypes::Secret;

#[test]
fn test_help_of_command_for_breaking_changes() {
    let output = test_bin::get_test_bin("pslink")
        .output()
        .expect("Failed to start pslink");
    assert!(String::from_utf8_lossy(&output.stdout).contains("USAGE"));

    let output = test_bin::get_test_bin("pslink")
        .args(&["--help"])
        .output()
        .expect("Failed to start pslink");
    let outstring = String::from_utf8_lossy(&output.stdout);

    let args = &[
        "USAGE",
        "-h",
        "--help",
        "-b",
        "-e",
        "-i",
        "-p",
        "-t",
        "-u",
        "runserver",
        "create-admin",
        "generate-env",
        "migrate-database",
        "help",
    ];

    for s in args {
        assert!(
            outstring.contains(s),
            "{} was not found in the help - this is a breaking change",
            s
        );
    }
}

#[test]
fn test_generate_env() {
    use std::io::BufRead;
    let tmp_dir = tempdir::TempDir::new("pslink_test_env").expect("create temp dir");
    let output = test_bin::get_test_bin("pslink")
        .args(&["generate-env", "--secret", "abcdefghijklmnopqrstuvw"])
        .current_dir(&tmp_dir)
        .output()
        .expect("Failed to start pslink");
    let envfile = tmp_dir.path().join(".env");
    let dbfile = tmp_dir.path().join("links.db");
    println!("{}", envfile.display());
    println!("{}", dbfile.display());
    println!("{}", String::from_utf8_lossy(&output.stdout));
    assert!(envfile.exists(), "No .env-file was created!");
    assert!(dbfile.exists(), "No database-file was created!");

    let envfile = std::fs::File::open(envfile).unwrap();
    let envcontent: Vec<Result<String, _>> = std::io::BufReader::new(envfile).lines().collect();
    assert!(
        envcontent
            .iter()
            .any(|s| s.as_ref().unwrap().starts_with("PSLINK_PORT=")),
        "Failed to find PSLINK_PORT in the generated .env file."
    );
    assert!(
        envcontent
            .iter()
            .any(|s| s.as_ref().unwrap().starts_with("PSLINK_SECRET=")),
        "Failed to find PSLINK_SECRET in the generated .env file."
    );
    assert!(
        !envcontent.iter().any(|s| {
            let r = s.as_ref().unwrap().contains("***SECRET***");
            r
        }),
        "It seems that a censored secret was used in the .env file."
    );
    assert!(
        envcontent.iter().any(|s| {
            let r = s.as_ref().unwrap().contains("abcdefghijklmnopqrstuvw");
            r
        }),
        "The secret has not made it into the .env file!"
    );
    let output = test_bin::get_test_bin("pslink")
        .args(&["generate-env"])
        .current_dir(&tmp_dir)
        .output()
        .expect("Failed to start pslink");
    let second_out = String::from_utf8_lossy(&output.stdout);
    assert!(!second_out.contains("secret"));
}

#[actix_rt::test]
async fn test_migrate_database() {
    use std::io::Write;
    #[derive(serde::Serialize, Debug)]
    pub struct Count {
        pub number: i32,
    }

    let tmp_dir = tempdir::TempDir::new("pslink_test_env").expect("create temp dir");
    // generate .env file
    let _output = test_bin::get_test_bin("pslink")
        .args(&["generate-env"])
        .current_dir(&tmp_dir)
        .output()
        .expect("Failed generate .env");

    // migrate the database
    let output = test_bin::get_test_bin("pslink")
        .args(&["migrate-database"])
        .current_dir(&tmp_dir)
        .output()
        .expect("Failed to migrate the database");
    println!("{}", String::from_utf8_lossy(&output.stdout));

    // check if the users table exists by counting the number of admins.
    let db_pool = sqlx::pool::Pool::<sqlx::sqlite::Sqlite>::connect(
        &tmp_dir.path().join("links.db").display().to_string(),
    )
    .await
    .expect("Error: Failed to connect to database!");
    let num = sqlx::query_as!(Count, "select count(*) as number from users where role = 2")
        .fetch_one(&db_pool)
        .await
        .unwrap();
    // initially no admin is present
    assert_eq!(num.number, 0, "Failed to create the database!");

    // create a new admin
    let mut input = test_bin::get_test_bin("pslink")
        .args(&["create-admin"])
        .current_dir(&tmp_dir)
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .spawn()
        .expect("Failed to migrate the database");
    let mut procin = input.stdin.take().unwrap();

    procin.write_all(b"test\n").unwrap();
    procin.write_all(b"test@mail.test\n").unwrap();
    procin.write_all(b"testpw\n").unwrap();

    let r = input.wait().unwrap();
    println!("Exitstatus is: {}", r);

    println!("{}", String::from_utf8_lossy(&output.stdout));
    let num = sqlx::query_as!(Count, "select count(*) as number from users where role = 2")
        .fetch_one(&db_pool)
        .await
        .unwrap();
    // now 1 admin is there
    assert_eq!(num.number, 1, "Failed to create an admin!");
}

async fn run_server() {
    use std::io::Write;
    #[derive(serde::Serialize, Debug)]
    pub struct Count {
        pub number: i32,
    }
    let tmp_dir = tempdir::TempDir::new("pslink_test_env").expect("create temp dir");
    // generate .env file
    let _output = test_bin::get_test_bin("pslink")
        .args(&["generate-env", "--secret", "abcdefghijklmnopqrstuvw"])
        .current_dir(&tmp_dir)
        .output()
        .expect("Failed generate .env");
    // migrate the database
    let output = test_bin::get_test_bin("pslink")
        .args(&["migrate-database"])
        .current_dir(&tmp_dir)
        .output()
        .expect("Failed to migrate the database");

    // create a database connection.
    let db_pool = sqlx::pool::Pool::<sqlx::sqlite::Sqlite>::connect(
        &tmp_dir.path().join("links.db").display().to_string(),
    )
    .await
    .expect("Error: Failed to connect to database!"); // create a new admin
    let mut input = test_bin::get_test_bin("pslink")
        .args(&["create-admin"])
        .current_dir(&tmp_dir)
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .spawn()
        .expect("Failed to migrate the database");
    let mut procin = input.stdin.take().unwrap();

    procin.write_all(b"test\n").unwrap();
    procin.write_all(b"test@mail.test\n").unwrap();
    procin.write_all(b"testpw\n").unwrap();

    let r = input.wait().unwrap();
    println!("Exitstatus is: {}", r);

    println!("{}", String::from_utf8_lossy(&output.stdout));
    let num = sqlx::query_as!(Count, "select count(*) as number from users where role = 2")
        .fetch_one(&db_pool)
        .await
        .unwrap();
    // now 1 admin is there
    assert_eq!(
        num.number, 1,
        "Failed to create an admin! See previous tests!"
    );

    let server_config = pslink::ServerConfig {
        secret: Secret::new("abcdefghijklmnopqrstuvw".to_string()),
        db: std::path::PathBuf::from("links.db"),
        db_pool,
        public_url: "localhost:8080".to_string(),
        internal_ip: "localhost".to_string(),
        port: 8080,
        protocol: pslink::Protocol::Http,
        empty_forward_url: "https://github.com/enaut/pslink".to_string(),
        brand_name: "Pslink".to_string(),
    };

    let server = pslink::webservice(server_config);

    let _neveruse = tokio::spawn(server);
}

#[actix_rt::test]
async fn test_web_paths() {
    run_server().await;

    // We need to bring in `reqwest`
    // to perform HTTP requests against our application.
    let client = reqwest::Client::builder()
        .cookie_store(true)
        .redirect(reqwest::redirect::Policy::none())
        .build()
        .unwrap();

    // Act
    let response = client
        .get("http://localhost:8080/")
        .send()
        .await
        .expect("Failed to execute request.");

    // The basic redirection is working!
    assert!(response.status().is_redirection());
    let location = response.headers().get("location").unwrap();
    assert!(location.to_str().unwrap().contains("github"));

    // Act
    let response = client
        .get("http://localhost:8080/admin/login/")
        .send()
        .await
        .expect("Failed to execute request.");

    // The Loginpage is reachable and contains a password field!
    assert!(response.status().is_success());
    let content = response.text().await.unwrap();
    assert!(
        content.contains(r#"<input type="password"#),
        "No password field was found!"
    );

    // Act
    let formdata = &[("username", "test"), ("password", "testpw")];
    let response = client
        .post("http://localhost:8080/admin/login/")
        .form(formdata)
        .send()
        .await
        .expect("Failed to execute request.");

    // It is possible to login
    assert!(response.status().is_redirection());
    let location = response.headers().get("location").unwrap();
    assert_eq!("/admin/index/", location.to_str().unwrap());
    assert!(
        response.headers().get("set-cookie").is_some(),
        "A auth cookie is not set even though authentication succeeds"
    );

    // After login this should return a redirect
    let response = client
        .get("http://localhost:8080/admin/login/")
        .send()
        .await
        .expect("Failed to execute request.");

    // The Loginpage redirects to link index when logged in
    assert!(
        response.status().is_redirection(),
        "/admin/login/ is not redirecting correctly when logged in!"
    );
    let location = response.headers().get("location").unwrap();
    assert_eq!("/admin/index/", location.to_str().unwrap());

    // After login this should return a redirect
    let response = client
        .get("http://localhost:8080/admin/index/")
        .send()
        .await
        .expect("Failed to execute request.");

    // The Loginpage redirects to link index when logged in
    assert!(
        response.status().is_success(),
        "Could not access /admin/index/"
    );
    let content = response.text().await.unwrap();
    assert!(
        content.contains(r#"<a href="/admin/logout/">"#),
        "No Logout Button was found on /admin/index/!"
    );

    // Act title=haupt&target=http%3A%2F%2Fdas.geht%2Fjetzt%2F&code=tpuah
    let formdata = &[
        ("title", "haupt"),
        ("target", "https://das.geht/jetzt/"),
        ("code", "tpuah"),
    ];
    let response = client
        .post("http://localhost:8080/admin/submit/")
        .form(formdata)
        .send()
        .await
        .expect("Failed to execute request.");

    // It is possible to login
    assert!(response.status().is_redirection());
    let location = response.headers().get("location").unwrap();
    assert_eq!("/admin/view/link/tpuah", location.to_str().unwrap());

    // Act
    let response = client
        .get("http://localhost:8080/tpuah")
        .send()
        .await
        .expect("Failed to execute request.");

    // The basic redirection is working!
    assert!(response.status().is_redirection());
    let location = response.headers().get("location").unwrap();
    assert!(location
        .to_str()
        .unwrap()
        .contains("https://das.geht/jetzt/"));
}