import argparse
import requests
from requests.auth import HTTPBasicAuth


def asset_collection_type(edg_url, graphId, username, password):
    url = f"{edg_url}/tbl/service/{graphId}/tbs/assetCollectionType"
    response = requests.post(
        url,
        headers={"accept": "application/json"},
        auth=HTTPBasicAuth(username, password),
    )
    response.raise_for_status()
    return response.content


def export_rdf(
    edg_url,
    graphID,
    username,
    password,
    exclude_values_rules,
    fmt,
    include_inferences,
    keep_edg_triples,
):
    url = f"{edg_url}/tbl/service/{graphID}/tbs/exportRDFFile"
    params = {
        "excludeValuesRules": str(exclude_values_rules).lower(),
        "format": fmt,
        "includeInferences": str(include_inferences).lower(),
        "keepEDGTriples": str(keep_edg_triples).lower(),
    }
    response = requests.get(url, auth=HTTPBasicAuth(username, password), params=params)
    response.raise_for_status()
    return response.content


def create_asset_collection(edg_url, graphID, type_label, username, password):
    url = f"{edg_url}/tbl/service/_/tbs/createAssetCollection"
    params = {
        "defaultNamespace": "www.temporary.org",
        "id": graphID,
        "name": graphID,
        "typeLabel": type_label,
    }
    response = requests.post(url, auth=HTTPBasicAuth(username, password), params=params)
    response.raise_for_status()
    return True


def import_rdf(edg_url, graphID, username, password, rdf_content, fmt="turtle"):
    url = f"{edg_url}/tbl/service/{graphID}/tbs/importRDFFile"
    files = {
        "file": (f"{graphID}.ttl", rdf_content, "text/turtle"),
        "fileName": (None, f"{graphID}.ttl"),
        "format": (None, fmt),
    }
    response = requests.post(
        url,
        files=files,
        auth=HTTPBasicAuth(username, password),
        headers={"accept": "application/json"},
    )
    response.raise_for_status()
    return True


def process_list(
    collections_file,
    url_source,
    url_target,
    source_username,
    source_password,
    target_username,
    target_password,
    exclude_values_rules,
    fmt,
    include_inferences,
    keep_edg_triples,
):

    with open(collections_file, "r") as file:
        collections = [line.strip() for line in file.readlines() if line.strip()]

    for graph_id in collections:
        rdf = export_rdf(
            url_source,
            graph_id,
            source_username,
            source_password,
            exclude_values_rules,
            fmt,
            include_inferences,
            keep_edg_triples,
        )
        type_label = asset_collection_type(
            url_source, graph_id, source_username, source_password
        )
        create_asset_collection(
            url_target, graph_id, type_label, target_username, target_password
        )
        import_rdf(url_target, graph_id, target_username, target_password, rdf, fmt=fmt)
        print(f"Migrated: {graph_id}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Export RDF from EDG and import into another EDG instance."
    )
    parser.add_argument("--collections_file", required=True)
    parser.add_argument("--url_source", required=True)
    parser.add_argument("--url_target", required=True)
    parser.add_argument("--source_username", required=True)
    parser.add_argument("--source_password", required=True)
    parser.add_argument("--target_username", required=True)
    parser.add_argument("--target_password", required=True)
    parser.add_argument("--excludeValuesRules", type=bool, default=True)
    parser.add_argument("--format", type=str, default="turtle")
    parser.add_argument("--includeInferences", type=bool, default=True)
    parser.add_argument("--keepEDGTriples", type=bool, default=True)
    args = parser.parse_args()

    process_list(
        args.collections_file,
        args.url_source,
        args.url_target,
        args.source_username,
        args.source_password,
        args.target_username,
        args.target_password,
        args.excludeValuesRules,
        args.format,
        args.includeInferences,
        args.keepEDGTriples,
    )