use crate::{
    Result,
    sharry::{AliasID, FileID, ShareID, Uri},
};

const VALID_URI: &str = "scheme://valid.uri";
const VALID_ALIAS: &str = "valid-alias";
const VALID_SHARE: &str = "valid-share";
const VALID_FILE: &str = "valid-file";

fn make_invalid(valid: &str) -> String {
    let invalid = valid.replace("valid", "invalid");
    assert_ne!(valid, invalid);

    invalid
}

pub trait CheckID {
    fn check(self) -> Result<()>;
}

impl CheckID for (&Uri, &AliasID) {
    fn check(self) -> Result<()> {
        if self.0.to_string() == make_invalid(VALID_URI) {
            Err(self.0.into())
        } else if self.1.as_ref() == make_invalid(VALID_ALIAS) {
            Err(self.1.into())
        } else {
            Ok(())
        }
    }
}

impl CheckID for &ShareID {
    fn check(self) -> Result<()> {
        if self.to_string() == make_invalid(VALID_SHARE) {
            Err(self.into())
        } else {
            Ok(())
        }
    }
}

impl CheckID for (&ShareID, &FileID) {
    fn check(self) -> Result<()> {
        self.0.check()?;

        if self.1.to_string() == make_invalid(VALID_FILE) {
            Err(self.1.into())
        } else {
            Ok(())
        }
    }
}

impl From<bool> for Uri {
    fn from(value: bool) -> Self {
        if value {
            Self::from(VALID_URI.to_string())
        } else {
            Self::from(make_invalid(VALID_URI))
        }
    }
}

impl From<bool> for AliasID {
    fn from(value: bool) -> Self {
        if value {
            Self::from(VALID_ALIAS.to_string())
        } else {
            Self::from(make_invalid(VALID_ALIAS))
        }
    }
}

impl From<bool> for ShareID {
    fn from(value: bool) -> Self {
        if value {
            Self::from(VALID_SHARE.to_string())
        } else {
            Self::from(make_invalid(VALID_SHARE))
        }
    }
}

impl From<bool> for FileID {
    fn from(value: bool) -> Self {
        if value {
            Self::new_test(VALID_FILE)
        } else {
            Self::new_test(make_invalid(VALID_FILE))
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::Parameter;

    use super::*;

    #[test]
    fn true_makes_valids() {
        let uri = Uri::from(true);
        let alias_id = AliasID::from(true);
        let share_id = ShareID::from(true);
        let file_id = FileID::from(true);

        assert!(matches!((&uri, &alias_id).check(), Ok(())));
        assert!(matches!(share_id.check(), Ok(())));
        assert!(matches!((&share_id, &file_id).check(), Ok(())));
    }

    #[test]
    fn default_is_valid() {
        let uri = Uri::default();
        let share_id = ShareID::default();
        let file_id = FileID::default();

        assert!(matches!((&uri, &AliasID::from(true)).check(), Ok(())));
        assert!(matches!(share_id.check(), Ok(())));
        assert!(matches!((&share_id, &file_id).check(), Ok(())));
    }

    #[test]
    fn false_makes_invalids() {
        let uri = Uri::from(true);
        let alias_id = AliasID::from(true);
        let share_id = ShareID::from(true);
        let file_id = FileID::from(true);

        let uri_i = Uri::from(false);
        let alias_id_i = AliasID::from(false);
        let share_id_i = ShareID::from(false);
        let file_id_i = FileID::from(false);

        // invalid Uri, valid alias
        let check = (&uri_i, &alias_id).check().expect_err("should be invalid");
        let p = check.get_invalid_param().expect("should be InvalidParam");
        assert!(matches!(p, Parameter::Uri(_)));

        // valid Uri, invalid alias
        let check = (&uri, &alias_id_i).check().expect_err("should be invalid");
        let p = check.get_invalid_param().expect("should be InvalidParam");
        assert!(matches!(p, Parameter::AliasID(_)));

        // invalid share
        let check = share_id_i.check().expect_err("should be invalid");
        let p = check.get_invalid_param().expect("should be InvalidParam");
        assert!(matches!(p, Parameter::ShareID(_)));

        // invalid share, valid file
        let check = (&share_id_i, &file_id)
            .check()
            .expect_err("should be invalid");
        let p = check.get_invalid_param().expect("should be InvalidParam");
        assert!(matches!(p, Parameter::ShareID(_)));

        // valid share, invalid file
        let check = (&share_id, &file_id_i)
            .check()
            .expect_err("should be invalid");
        let p = check.get_invalid_param().expect("should be InvalidParam");
        assert!(matches!(p, Parameter::FileID(_)));
    }
}