// zotapi - Rust wrapper for Sot API as implemented by Hubzilla
// Copyright (C) 2018  Harald Eilertsen <haraldei@anduin.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use mockito::{mock, Matcher, Mock};

fn mock_with_authorization(method: &str, url: &str) -> Mock {
    mock(method, url).match_header(
        "Authorization",
        Matcher::Exact(format!("Basic {}", base64::encode("testuser:test1234"))),
    )
}

fn default_mock(method: &str, url: &str) -> Mock {
    mock_with_authorization(method, url)
        .with_status(200)
        .with_header("content-type", "application/json")
        .with_body("[]")
        .create()
}

fn client() -> zotapi::ZotApi {
    zotapi::new(&mockito::server_url(), "testuser", "test1234")
}

#[tokio::test]
async fn get_channel_stream() {
    let m = default_mock("GET", "/api/z/1.0/channel/stream");
    client().channel_stream().await.unwrap();
    m.assert();
}

// #[tokio::test]
// async fn get_network_stream() {
//     let m = default_mock("GET", "/api/z/1.0/network/stream");
//     client().network_stream().await.unwrap();
//     m.assert();
// }

#[tokio::test]
async fn return_error_if_invalid_auth_provided() {
    let m = mock("GET", "/api/z/1.0/channel/stream")
        .with_status(401)
        .with_header("content-type", "text")
        .with_body("This api requires login")
        .create();

    let data = dbg!(client().channel_stream().await);
    m.assert();
    assert!(data.is_err());
    assert_eq!(format!("{:?}", data), "Err(Unauthorized)");
}

// #[tokio::test]
// async fn create_new_post() {
//     let m = mock_with_authorization("POST", "/api/z/1.0/item/update")
//         .match_body("body=This+is+a+test")
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::item().body("This is a test").create(&client()).await;
//
//     m.assert();
// }

// #[tokio::test]
// async fn create_new_post_with_title() {
//     let m = mock_with_authorization("POST", "/api/z/1.0/item/update")
//         .match_body(Matcher::AllOf(vec![
//             Matcher::UrlEncoded("title".to_string(), "A title".to_string()),
//             Matcher::UrlEncoded("body".to_string(), "This is a test".to_string()),
//         ]))
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::item()
//         .title("A title")
//         .body("This is a test")
//         .create(&client())
//         .await;
//
//     m.assert();
// }

// #[tokio::test]
// async fn create_new_post_limited_to_one_privacy_group() {
//     // For some reason this mock does not match.
//     // Visually inspecting the payload it does however seem valid,
//     // so not sure how to handle this with the current framework.
//     //
//     // For now this test makes no assertions, but at least it runs
//     // through the code paths it should.
//     let _m = mock_with_authorization("POST", "/api/z/1.0/item/update")
//         .match_body(Matcher::AllOf(vec![
//             Matcher::UrlEncoded("body".to_string(), "This is a test".to_string()),
//             Matcher::UrlEncoded("groups_allow[0]".to_string(), "grouphash".to_string()),
//         ]))
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::item()
//         .body("This is a test")
//         .group_allow("grouphash")
//         .create(&client())
//         .await;
//
//     //m.assert();
// }

// #[tokio::test]
// async fn upload_item_with_media_file() {
//     let m = mock_with_authorization("POST", "/api/z/1.0/item/update")
//         .match_header(
//             "content-type",
//             Matcher::Regex("multipart/form-data; boundary=.+".into()),
//         )
//         .match_body(Matcher::Regex(
//             "--.+\r\n".to_owned()
//                 + "Content-Disposition: form-data; name=\"body\"\r\n"
//                 + "\r\nThis is a test\r\n"
//                 + "--.+\r\n"
//                 + "Content-Disposition: form-data; name=\"title\"\r\n"
//                 + "\r\nA title\r\n"
//                 + "--.+\r\n"
//                 + "Content-Disposition: form-data; name=\"media\"; filename=\"testfile.txt\"\r\n"
//                 + "\r\ntestfile contents\n"
//                 + "\r\n--.+--\r\n",
//         ))
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::item()
//         .title("A title")
//         .body("This is a test")
//         .file("tests/fixtures/testfile.txt")
//         .create(&client())
//         .await;
//
//     m.assert();
// }

// #[tokio::test]
// async fn upload_item_with_two_files() {
//     let m = mock_with_authorization("POST", "/api/z/1.0/item/update")
//         .match_header(
//             "content-type",
//             Matcher::Regex("multipart/form-data; boundary=.+".into()),
//         )
//         .match_body(Matcher::Regex(
//             "--.+\r\n".to_owned()
//                 + "Content-Disposition: form-data; name=\"body\"\r\n"
//                 + "\r\nThis is a test\r\n"
//                 + "--.+\r\n"
//                 + "Content-Disposition: form-data; name=\"title\"\r\n"
//                 + "\r\nA title\r\n"
//                 + "--.+\r\n"
//                 + "Content-Disposition: form-data; name=\"media\"; filename=\"testfile.txt\"\r\n"
//                 + "\r\ntestfile contents\n"
//                 + "\r\n--.+\r\n"
//                 + "Content-Disposition: form-data; name=\"media\"; filename=\"testfile.txt\"\r\n"
//                 + "\r\ntestfile contents\n"
//                 + "\r\n--.+--\r\n",
//         ))
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::item()
//         .title("A title")
//         .body("This is a test")
//         .file("tests/fixtures/testfile.txt")
//         .file("tests/fixtures/testfile.txt")
//         .create(&client())
//         .await;
//
//     m.assert();
// }

// const EMPTY_XCHAN: &str = r#"{
//     "hash": "",
//     "guid": "",
//     "guid_sig": "",
//     "pubkey": "",
//     "photo_mimetype": "",
//     "photo_l": "",
//     "photo_m": "",
//     "photo_s": "",
//     "address": "",
//     "url": "",
//     "connurl": "",
//     "follow": "",
//     "connpage": "",
//     "name": "",
//     "network": "",
//     "instance_url": "",
//     "flags": 0,
//     "photo_date": "",
//     "name_date": "",
//     "hidden": 0,
//     "orphan": 0,
//     "censored": 0,
//     "selfcensored": 0,
//     "system": 0,
//     "pubforum": 0,
//     "deleted": 0
// }"#;

// #[tokio::test]
// async fn fetch_xchan_by_address() {
//     let m = mock_with_authorization("GET", "/api/z/1.0/xchan?address=test%40test.com")
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body(&EMPTY_XCHAN)
//         .create();
//
//     let _res = zotapi::XChan::z()
//         .by_address("test@test.com")
//         .fetch(&client())
//         .await
//         .unwrap();
//
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_xchan_by_hash() {
//     let m = mock_with_authorization("GET", "/api/z/1.0/xchan?hash=baffebaff")
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body(&EMPTY_XCHAN)
//         .create();
//
//     let _res = zotapi::XChan::z()
//         .by_hash("baffebaff")
//         .fetch(&client())
//         .await
//         .unwrap();
//
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_xchan_by_guid() {
//     let m = mock_with_authorization("GET", "/api/z/1.0/xchan?guid=baffebaff-baff-baff")
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body(&EMPTY_XCHAN)
//         .create();
//
//     let _res = zotapi::XChan::z()
//         .by_guid("baffebaff-baff-baff")
//         .fetch(&client())
//         .await
//         .unwrap();
//
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_connections() {
//     let m = default_mock("GET", "/api/z/1.0/abook");
//     let _res = zotapi::Abook::z().fetch(&client()).await.unwrap();
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_abconfig() {
//     let data = r#"
//         [
//             {
//                 "id": 666,
//                 "chan": 42,
//                 "xchan": "xchanhash1",
//                 "cat": "some_other_cat",
//                 "k": "key1",
//                 "v": "value1"
//             },
//             {
//                 "id": 667,
//                 "chan": 44,
//                 "xchan": "xchanhash2",
//                 "cat": "some_cat",
//                 "k": "key2",
//                 "v": "value2"
//             }
//
//         ]"#;
//
//     let m = mock_with_authorization("GET", "/api/z/1.0/abconfig")
//         .with_status(200)
//         .with_body(&data)
//         .create();
//
//     let res = zotapi::ABConfig::z().fetch(&client()).await.unwrap();
//     m.assert();
//
//     assert_eq!(res.len(), 2);
//     assert_eq!(res[0].id, 666);
//     assert_eq!(res[1].k, "key2");
// }

// #[tokio::test]
// async fn fetch_abconfig_for_specific_contact() {
//     let m = mock_with_authorization("GET", "/api/z/1.0/abconfig")
//         .match_query(Matcher::UrlEncoded("abook_id".into(), 42.to_string()))
//         .with_status(200)
//         .with_body("[]")
//         .create();
//
//     zotapi::ABConfig::z().with_abook_id(42).fetch(&client()).await.unwrap();
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_privacy_groups() {
//     let m = default_mock("GET", "/api/z/1.0/group");
//     let _res = zotapi::group().fetch(&client()).await.unwrap();
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_members_of_group_by_group_id() {
//     let m = mock_with_authorization("GET", "/api/z/1.0/group_members")
//         .match_query(Matcher::UrlEncoded(
//             "group_id".to_string(),
//             "42".to_string(),
//         ))
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::group_members()
//         .by_group_id(42)
//         .fetch(&client())
//         .await
//         .unwrap();
//
//     m.assert();
// }

// #[tokio::test]
// async fn fetch_members_of_group_by_group_name() {
//     let m = mock_with_authorization("GET", "/api/z/1.0/group_members")
//         .match_query(Matcher::UrlEncoded(
//             "group_name".into(),
//             "Friends of pain".into(),
//         ))
//         .with_status(200)
//         .with_header("content-type", "application/json")
//         .with_body("{}")
//         .create();
//
//     let _res = zotapi::group_members()
//         .by_group_name("Friends of pain")
//         .fetch(&client())
//         .await
//         .unwrap();
//
//     m.assert();
// }