import os
from loguru import logger

import defectdojo_api
from defectdojo_api.rest import ApiException as DefectDojoApiException
import datetime
from dateutil.relativedelta import relativedelta

import dependencytrack_api
from dependencytrack_api.rest import ApiException as DependencyTrackApiException

class MyLocalException(Exception): pass

def executeApiCall(apiClient, ApiClass, EndpointMethod, RequestClass, requestParams, additionalParams=[]):
    try:
        logger.info(f"Calling {ApiClass}.{EndpointMethod} with {RequestClass} ({additionalParams}, {requestParams})")
        instance = ApiClass(apiClient)
        request = RequestClass(**requestParams)
        response = EndpointMethod(instance, *additionalParams, request)
        logger.info(f"Response is {response}")
        return response
    except Exception as e:
        logger.error(f"Caught error {e} with {str(e)}")
        raise MyLocalException(e)



try:
    DTRACK_API_URL = os.environ["DTRACK_API_URL"]
    DTRACK_TOKEN = os.environ["DTRACK_TOKEN"]
    DEFECTDOJO_URL = os.environ["DEFECTDOJO_URL"]
    DEFECTDOJO_TOKEN = os.environ["DEFECTDOJO_TOKEN"]
except KeyError as e:
    raise Exception(f"Env variable {e} is shall be set")



defectdojo_configuration = defectdojo_api.Configuration(
    host = DEFECTDOJO_URL
)
defectdojo_configuration.api_key['tokenAuth'] = DEFECTDOJO_TOKEN
defectdojo_configuration.api_key_prefix['tokenAuth'] = 'Token'

dependencytrack_configuration = dependencytrack_api.Configuration(
    host = f"{DTRACK_API_URL}/api"
)
dependencytrack_configuration.debug = False
dependencytrack_configuration.api_key['ApiKeyAuth'] = DTRACK_TOKEN

with defectdojo_api.ApiClient(defectdojo_configuration) as defectdojo_api_client:
    print("Create product in DefectDojo")
    product_response = \
        executeApiCall(
           defectdojo_api_client, 
           defectdojo_api.ProductsApi, 
           defectdojo_api.ProductsApi.products_create, 
           defectdojo_api.ProductRequest,
           { 'name': "Test Product", 'description': "Just a product to test the API", 'prod_type': 1 },
           []
        )

    product_id = product_response.id
    print(f"{product_id=}")

    print("Create engagement in DefectDojo")
    start_time = datetime.date.today()
    end_time = start_time + relativedelta(years=10)
    engagement_response = \
        executeApiCall(
           defectdojo_api_client, 
           defectdojo_api.EngagementsApi, 
           defectdojo_api.EngagementsApi.engagements_create, 
           defectdojo_api.EngagementRequest,
           { 'name': "Test Engagement 01", 'target_start': start_time, 'target_end': end_time, 'status': 'In Progress', 'product': product_id },
           []
        )
    
    engagement_id = engagement_response.id
    print(f"{engagement_id=}")

with dependencytrack_api.ApiClient(dependencytrack_configuration) as dependencytrack_api_client:
    project_response = \
        executeApiCall(
           dependencytrack_api_client,
           dependencytrack_api.ProjectApi, 
           dependencytrack_api.ProjectApi.create_project,
           dependencytrack_api.Project,
           { 'name': "Test Project", 'uuid': "", 'last_bom_import': 0 },
           []
        )

    project_uuid = project_response.uuid
    print(f"{project_uuid=}")

    properties = [
        { 'group_name': "integrations", 'property_name': "defectdojo.engagementId", 'property_value': str(engagement_id), 'property_type': "STRING" },
        { 'group_name': "integrations", 'property_name': "defectdojo.doNotReactivate", 'property_value': "true", 'property_type': "BOOLEAN" },
        { 'group_name': "integrations", 'property_name': "defectdojo.reimport", 'property_value': "true", 'property_type': "BOOLEAN" }
    ]
    for property in properties:
        executeApiCall(
            dependencytrack_api_client,
            dependencytrack_api.ProjectPropertyApi,
            dependencytrack_api.ProjectPropertyApi.create_property1,
            dependencytrack_api.ProjectProperty,
            property,
            [ project_uuid ]
        )