from core.Constants import Constants
from core.models.ClientVersion import ClientVersion
from core.models.orm_models.Location import Location
from core.models.orm_models.Operator import Operator
from core.models.Subscription import Subscription
from core.models.SubscriptionPlan import SubscriptionPlan
from core.models.invoice.Invoice import Invoice
from core.models.invoice.PaymentMethod import PaymentMethod
from core.models.session.Application import Application
# from core.models.session.ApplicationVersion import ApplicationVersion
from core.models.orm_models.ApplicationVersion import ApplicationVersion

from core.models.session.ProxyConfiguration import ProxyConfiguration
from typing import Optional
import re


class WebServiceApiService:

    @staticmethod
    def get_applications(proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/platforms/linux-x86_64/applications', None, proxies)
        applications = []

        if response.status_code == status_codes.OK:
            for application in response.json()['data']:
                applications.append(Application(application['code'], application['name'], application['id']))

        return applications

    @staticmethod
    def get_application_versions(code: str, proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get(f'/platforms/linux-x86_64/applications/{code}/application-versions', None, proxies)
        application_versions = []

        if response.status_code == status_codes.OK:
            for application_version in response.json()['data']:
                application_versions.append(ApplicationVersion(code, application_version['version_number'], application_version['format_revision'], application_version['id'], application_version['download_path'], application_version['released_at'], application_version['file_hash']))

        return application_versions

    @staticmethod
    def get_client_versions(proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/platforms/linux-x86_64/appimage/client-versions', None, proxies)
        client_versions = []

        if response.status_code == status_codes.OK:
            for client_version in response.json()['data']:
                client_versions.append(ClientVersion(client_version['version_number'], client_version['released_at'], client_version['id'], client_version['download_path']))

        return client_versions

    @staticmethod
    def get_operators(proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/operators', None, proxies)
        operators = []

        if response.status_code == status_codes.OK:
            for operator in response.json()['data']:
                operators.append(Operator(operator['id'], operator['name'], operator['public_key'], operator['nostr_public_key'], operator['nostr_profile_reference'], operator['nostr_attestation']['event_reference']))

        return operators

    @staticmethod
    def get_locations(proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/locations', None, proxies)
        locations = []

        if response.status_code == status_codes.OK:
            for location in response.json()['data']:
                locations.append(Location(location['country']['code'], location['code'], location['id'], location['country']['name'], location['name'], location['time_zone']['code'], location['operator_id'], location['provider']['name'], location['is_proxy_capable'], location['is_wireguard_capable']))

        return locations

    @staticmethod
    def get_subscription_plans(proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/subscription-plans', None, proxies)
        subscription_plans = []

        if response.status_code == status_codes.OK:
            for subscription_plan in response.json()['data']:
                subscription_plans.append(SubscriptionPlan(subscription_plan['id'], subscription_plan['code'], subscription_plan['wireguard_session_limit'], subscription_plan['duration'], subscription_plan['price'], subscription_plan['features_proxy'], subscription_plan['features_wireguard']))

        return subscription_plans

    @staticmethod
    def post_subscription(subscription_plan_id, location_id, proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__post('/subscriptions', None, {
            'subscription_plan_id': subscription_plan_id,
            'location_id': location_id
        }, proxies)

        if response.status_code == status_codes.CREATED:
            return Subscription(response.headers['X-Billing-Code'])

        else:
            return None

    @staticmethod
    def get_subscription(billing_code: str, proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        billing_code = billing_code.replace('-', '').upper()
        billing_code_fragments = re.findall('....?', billing_code)
        billing_code = '-'.join(billing_code_fragments)

        response = WebServiceApiService.__get('/subscriptions/current', billing_code, proxies)

        if response.status_code == status_codes.OK:

            subscription = response.json()['data']
            return Subscription(billing_code, Subscription.from_iso_format(subscription['expires_at']))

        else:
            return None

    @staticmethod
    def get_invoice(billing_code: str, proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/invoices/current', billing_code, proxies)

        if response.status_code == status_codes.OK:

            response_data = response.json()['data']

            invoice = {
                'status': response_data['status'],
                'expires_at': response_data['expires_at']
            }

            payment_methods = []

            for payment_method in response_data['payment_methods']:
                payment_methods.append(PaymentMethod(payment_method['code'], payment_method['name'], payment_method['address'], payment_method['payment_link'], payment_method['rate'], payment_method['amount'], payment_method['due']))

            return Invoice(billing_code, invoice['status'], invoice['expires_at'], tuple[PaymentMethod](payment_methods))

        else:
            return None

    @staticmethod
    def get_proxy_configuration(billing_code: str, proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__get('/proxy-configurations/current', billing_code, proxies)

        if response.status_code == status_codes.OK:

            proxy_configuration = response.json()['data']
            return ProxyConfiguration(proxy_configuration['ip_address'], proxy_configuration['port'], proxy_configuration['username'], proxy_configuration['password'], proxy_configuration['location']['time_zone']['code'])

        else:
            return None

    @staticmethod
    def post_wireguard_session(country_code: str, location_code: str, billing_code: str, public_key: str, proxies: Optional[dict] = None):

        from requests.status_codes import codes as status_codes

        response = WebServiceApiService.__post(f'/countries/{country_code}/locations/{location_code}/wireguard-sessions', billing_code, {
            'public_key': public_key,
        }, proxies)

        if response.status_code == status_codes.CREATED:
            return response.text
        else:
            return None

    @staticmethod
    def __get(path, billing_code: Optional[str] = None, proxies: Optional[dict] = None):

        import requests

        if billing_code is not None:
            headers = {'X-Billing-Code': billing_code}
        else:
            headers = None

        return requests.get(Constants.SP_API_BASE_URL + path, headers=headers, proxies=proxies)

    @staticmethod
    def __post(path, billing_code: Optional[str] = None, body: Optional[dict] = None, proxies: Optional[dict] = None):

        import requests

        if billing_code is not None:
            headers = {'X-Billing-Code': billing_code}
        else:
            headers = None

        return requests.post(Constants.SP_API_BASE_URL + path, headers=headers, json=body, proxies=proxies)

    # @staticmethod
    # def get_cached_sync(proxies: Optional[dict] = None):

    #     from requests.status_codes import codes as status_codes

    #     response = WebServiceApiService.__get('/cachedsync', None, proxies)

    #     if response.status_code == status_codes.OK:
    #         return response.json()
    #     else:
    #         return None