use std::fs;

use git_config::{
    file::{includes, init, init::from_paths},
    File,
};
use tempfile::tempdir;

use crate::file::{
    cow_str,
    init::from_paths::{escape_backslashes, into_meta},
};

fn follow_options() -> init::Options<'static> {
    init::Options {
        includes: includes::Options::follow(Default::default(), Default::default()),
        ..Default::default()
    }
}

#[test]
fn multiple() -> crate::Result {
    let dir = tempdir()?;

    let a_path = dir.path().join("a");
    fs::write(
        a_path.as_path(),
        "
[core]
  a = false
  sslVerify = true
  d = 41",
    )?;

    let b_path = dir.path().join("b");
    let relative_b_path: std::path::PathBuf = "b".into();
    fs::write(
        b_path.as_path(),
        "
[diff]
  renames = true",
    )?;
    let ignore_path = dir.path().join("ignore");
    fs::write(
        ignore_path.as_path(),
        "
[diff]
  renames = invalid",
    )?;

    let a_path_string = escape_backslashes(a_path.parent().unwrap());
    let non_canonical_path_a = format!("{}/./a", a_path_string);
    let non_existing_path = "/dfgwfsghfdsfs";
    let c_path = dir.path().join("c");
    fs::write(
        c_path.as_path(),
        format!(
            "
[core]
  c = 12
  d = 42
[include]
  path = {}
  path = {}
  path = {}
[include.ignore]
  path = {}
[http]
  sslVerify = false",
            non_existing_path,
            non_canonical_path_a,
            relative_b_path.as_path().to_str().unwrap(),
            escape_backslashes(&ignore_path)
        ),
    )?;

    let config = File::from_paths_metadata(into_meta(vec![c_path]), follow_options())?.expect("non-empty");

    assert_eq!(config.string("core", None, "c"), Some(cow_str("12")));
    assert_eq!(config.integer("core", None, "d"), Some(Ok(41)));
    assert_eq!(config.boolean("http", None, "sslVerify"), Some(Ok(false)));
    assert_eq!(config.boolean("diff", None, "renames"), Some(Ok(true)));
    assert_eq!(config.boolean("core", None, "a"), Some(Ok(false)));

    Ok(())
}

#[test]
fn respect_max_depth() -> crate::Result {
    let dir = tempdir()?;

    // 0 includes 1 - base level
    // 1 includes 2
    // 2 includes 3
    // 3 includes 4
    // 4 has no includes
    let max_depth = 4u8;
    for (i, next_i) in (0..max_depth).zip(1..=max_depth) {
        let path = dir.path().join(i.to_string());
        let next_path = dir.path().join(next_i.to_string());
        fs::write(
            path.as_path(),
            format!(
                "
        [core]
          i = {i} 
        [include]
          path = {}",
                escape_backslashes(&next_path),
            ),
        )?;
    }

    fs::write(
        dir.path().join(max_depth.to_string()),
        "
        [core]
          i = {}"
            .replace("{}", &max_depth.to_string()),
    )?;

    let config =
        File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), follow_options())?.expect("non-empty");
    assert_eq!(config.integers("core", None, "i"), Some(Ok(vec![0, 1, 2, 3, 4])));

    fn make_options(max_depth: u8, error_on_max_depth_exceeded: bool) -> init::Options<'static> {
        init::Options {
            includes: includes::Options {
                max_depth,
                err_on_max_depth_exceeded: error_on_max_depth_exceeded,
                ..Default::default()
            },
            ..Default::default()
        }
    }

    // with max_allowed_depth of 1 and 4 levels of includes and error_on_max_depth_exceeded: false, max_allowed_depth is exceeded and the value of level 1 is returned
    // this is equivalent to running git with --no-includes option
    let options = make_options(1, false);
    let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
    assert_eq!(config.integer("core", None, "i"), Some(Ok(1)));

    // with default max_allowed_depth of 10 and 4 levels of includes, last level is read
    let options = init::Options {
        includes: includes::Options::follow(Default::default(), Default::default()),
        ..Default::default()
    };
    let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
    assert_eq!(config.integer("core", None, "i"), Some(Ok(4)));

    // with max_allowed_depth of 5, the base and 4 levels of includes, last level is read
    let options = make_options(5, false);
    let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
    assert_eq!(config.integer("core", None, "i"), Some(Ok(4)));

    // with max_allowed_depth of 2 and 4 levels of includes, max_allowed_depth is exceeded and error is returned
    let options = make_options(2, true);
    let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options);
    assert!(matches!(
        config.unwrap_err(),
        from_paths::Error::Init(init::Error::Includes(includes::Error::IncludeDepthExceeded {
            max_depth: 2
        }))
    ));

    // with max_allowed_depth of 2 and 4 levels of includes and error_on_max_depth_exceeded: false , max_allowed_depth is exceeded and the value of level 2 is returned
    let options = make_options(2, false);
    let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options)?.expect("non-empty");
    assert_eq!(config.integer("core", None, "i"), Some(Ok(2)));

    // with max_allowed_depth of 0 and 4 levels of includes, max_allowed_depth is exceeded and error is returned
    let options = make_options(0, true);
    let config = File::from_paths_metadata(into_meta(vec![dir.path().join("0")]), options);
    assert!(matches!(
        config.unwrap_err(),
        from_paths::Error::Init(init::Error::Includes(includes::Error::IncludeDepthExceeded {
            max_depth: 0
        }))
    ));
    Ok(())
}

#[test]
fn simple() -> crate::Result {
    let dir = tempdir()?;

    let a_path = dir.path().join("a");
    let b_path = dir.path().join("b");

    fs::write(
        a_path.as_path(),
        format!(
            "
[core]
  b = true
[include]
  path = {}
[core]
  b = true
[include]
  path = {}",
            escape_backslashes(&b_path),
            escape_backslashes(&b_path)
        ),
    )?;

    fs::write(
        b_path.as_path(),
        "
[core]
  b = false",
    )?;

    let config = File::from_paths_metadata(into_meta(vec![a_path]), follow_options())?.expect("non-empty");
    assert_eq!(config.boolean("core", None, "b"), Some(Ok(false)));
    Ok(())
}

#[test]
fn cycle_detection() -> crate::Result {
    let dir = tempdir()?;

    let a_path = dir.path().join("a");
    let b_path = dir.path().join("b");

    fs::write(
        a_path.as_path(),
        format!(
            "
[core]
  b = 0
[include]
  path = {}",
            escape_backslashes(&b_path),
        ),
    )?;

    fs::write(
        b_path.as_path(),
        format!(
            "
[core]
  b = 1
[include]
  path = {}",
            escape_backslashes(&a_path),
        ),
    )?;

    let options = init::Options {
        includes: includes::Options {
            max_depth: 4,
            err_on_max_depth_exceeded: true,
            ..Default::default()
        },
        ..Default::default()
    };
    let config = File::from_paths_metadata(into_meta(vec![a_path.clone()]), options);
    assert!(matches!(
        config.unwrap_err(),
        from_paths::Error::Init(init::Error::Includes(includes::Error::IncludeDepthExceeded {
            max_depth: 4
        }))
    ));

    let options = init::Options {
        includes: includes::Options {
            max_depth: 4,
            err_on_max_depth_exceeded: false,
            ..Default::default()
        },
        ..Default::default()
    };
    let config = File::from_paths_metadata(into_meta(vec![a_path]), options)?.expect("non-empty");
    assert_eq!(config.integers("core", None, "b"), Some(Ok(vec![0, 1, 0, 1, 0])));
    Ok(())
}

#[test]
fn nested() -> crate::Result {
    let dir = tempdir()?;

    let a_path = dir.path().join("a");
    fs::write(
        a_path.as_path(),
        "
[core]
  a = false
  c = 1",
    )?;

    let b_path = dir.path().join("b");
    fs::write(
        b_path.as_path(),
        format!(
            "
[core]
  b = true
[include]
  path = {}",
            escape_backslashes(&a_path)
        ),
    )?;

    let c_path = dir.path().join("c");
    fs::write(
        c_path.as_path(),
        format!(
            "
[core]
  c = 12
[include]
  path = {}",
            escape_backslashes(&b_path)
        ),
    )?;

    let config = File::from_paths_metadata(into_meta(vec![c_path]), follow_options())?.expect("non-empty");

    assert_eq!(config.integer("core", None, "c"), Some(Ok(1)));
    assert_eq!(config.boolean("core", None, "b"), Some(Ok(true)));
    assert_eq!(config.boolean("core", None, "a"), Some(Ok(false)));
    Ok(())
}