import json

from src import config
from src.api_utils.errors import BadRequest, NotFound, Unauthorized
from src.api_utils.handler import api_handler
from src.api_utils.request import Request
from src.api_utils.response import Response, redirect
from src.api_utils.spec import cookies_schema, docs, path_schema, querystring_schema, response_schema
from src.core.schemas import ApplicationRequestSchema
from src.enums import ServiceType
from src.logger import BoundLogger
from src.utils import get_api_url, get_authorized_api_client

from .authorizer import AppleMusicAuthorizer, get_authorizer
from .authorizer.error import ServiceAuthorizationError
# <<<<<<< HEAD
# from .schemas import AddServiceAccountRequestSchema, AppleMusicTokenSchema, BaseCallbackSchema, \
#     ListServiceAccountResponseSchema, MarketIdSchema, ServiceTypeSchema
# =======
from .schemas import AddServiceAccountRequestSchema, AppleMusicTokenSchema, BaseCallbackSchema, \
    ExtraInfoRequestSchema, ExtraInfoResponseSchema, ListServiceAccountResponseSchema, MarketIdSchema, \
    ServiceTypeSchema
# >>>>>>> develop
from .services import ServiceAccountService


@api_handler
@docs(tags=("service_accounts",), summary="List service accounts")
@path_schema(ApplicationRequestSchema)
@response_schema(code=Unauthorized.status_code, description="Unauthorized")
@response_schema(ListServiceAccountResponseSchema(many=True), description="List service accounts")
def list_service_accounts(_request: Request, logger: BoundLogger, app_id: int) -> Response:
    service = ServiceAccountService()
    service_accounts = service.select_for_app(app_id)
    return Response(ListServiceAccountResponseSchema().dumps(service_accounts, many=True))


# @api_handler
# @docs(tags=("service_accounts",), summary="Delete service account")
# @response_schema(code=202, description="service account successfully deleted")
# @response_schema(code=NotFound.status_code, description="playlist sync object doesn't exists")
# def delete_service_account(_request: Request, logger: BoundLogger, app_id: int, acc_id: int) -> Response:
#     service = ServiceAccountService()
#     if not service.exists_by_pk(acc_id):
#         raise NotFound()
#
#     service.delete_by_pk(acc_id)
#
#     return Response(status_code=202)


@api_handler
@docs(tags=("service_accounts",), summary="Redirect to DSP oauth service")
@path_schema(ServiceTypeSchema)
@querystring_schema(AddServiceAccountRequestSchema)
@response_schema(code=302, description="Redirect to DSP oauth service")
@response_schema(code=NotFound.status_code, description="Unknown service")
@response_schema(code=Unauthorized.status_code, description="Unauthorized")
@response_schema(code=BadRequest.status_code, description="BadRequest")
def authorize(request: Request, logger: BoundLogger, service_type: ServiceType) -> Response:
    authorizer = get_authorizer(service_type, logger=logger)
    if authorizer is None:
        raise NotFound(f"Unknown service '{service_type.name}'")
    authorizer.set_callback_host(get_api_url(request.schema, request.host))

    data = AddServiceAccountRequestSchema().load(request.query_parameters)

    response = redirect(authorizer.get_auth_url())
    response.set_cookie(config.MARKET_ID_COOKIE_NAME, data["market_id"], secure=True, rest={"HttpOnly": True})
    return response


@api_handler
@docs(tags=("service_accounts",), summary="Returns DSP auth request")
@path_schema(ServiceTypeSchema)
@querystring_schema(AddServiceAccountRequestSchema)
@response_schema(description="DSP auth request")
@response_schema(code=NotFound.status_code, description="Unknown service")
@response_schema(code=Unauthorized.status_code, description="Unauthorized")
@response_schema(code=BadRequest.status_code, description="BadRequest")
def authorize_data(request: Request, logger: BoundLogger, service_type: ServiceType) -> Response:
    authorizer = get_authorizer(service_type, logger=logger)
    if authorizer is None:
        raise NotFound(f"Unknown service '{service_type.name}'")
    authorizer.set_callback_host(get_api_url(request.schema, request.host))

    data = AddServiceAccountRequestSchema().load(request.query_parameters)

    response = Response(
        json.dumps({"url": authorizer.get_auth_url(), "cookies": {config.MARKET_ID_COOKIE_NAME: data["market_id"]}})
    )
    response.set_cookie(config.MARKET_ID_COOKIE_NAME, data["market_id"], secure=True, rest={"HttpOnly": True})
    return response


@api_handler
@docs(tags=("service_accounts",), summary="Webhook to be called by 3rd party oauth service")
@path_schema(ServiceTypeSchema)
@cookies_schema(MarketIdSchema)
@querystring_schema(BaseCallbackSchema)
@response_schema(description="Service account been added successfully")
@response_schema(code=NotFound.status_code, description="Unknown service")
@response_schema(code=Unauthorized.status_code, description="Unauthorized")
@response_schema(code=BadRequest.status_code, description="BadRequest")
def auth_callback(request: Request, logger: BoundLogger, service_type: ServiceType) -> Response:
    authorizer = get_authorizer(service_type, logger=logger)
    if authorizer is None:
        raise NotFound(f"Unknown service '{service_type.name}'")
    authorizer.set_callback_host(get_api_url(request.schema, request.host))

    data = authorizer.callback_schema.load(request.query_parameters)
    app_id = request.cookies.get(config.MARKET_ID_COOKIE_NAME) or data.get(config.MARKET_ID_COOKIE_NAME)

    try:
        service_account = authorizer.complete_auth(app_id, **data)
    except ServiceAuthorizationError as e:
        raise Unauthorized from e

    # TODO: Consider upsert
    ServiceAccountService().insert_instance(service_account)

    return Response()


@api_handler
@docs(tags=("service_accounts",), summary="Returns apple music developer token (required for apple music auth)")
@response_schema(AppleMusicTokenSchema)
def apple_music_dt(request: Request, logger: BoundLogger) -> Response:
    authorizer = AppleMusicAuthorizer(logger=logger)
    return Response(AppleMusicTokenSchema().dumps({"token": authorizer.get_dev_token()}))


@api_handler
@path_schema(ApplicationRequestSchema)
def apple_music_tmp(request: Request, logger: BoundLogger, app_id: int) -> Response:
    dt_url = "/dev/_serviceaccounts/apple_music_dt"
    callback_url = "/dev/_serviceaccounts/callback/apple_music"
    data = f"""
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Apple musicKit</title>
        <script src="https://js-cdn.music.apple.com/musickit/v3/musickit.js" async></script>
    </head>
    <body>
    <button id="unauth_btn">Unauthorize</button>
    <button id="auth_btn">Authorize</button>
    <script>
        function redirect(data) {{
            const query = new URLSearchParams(data).toString();
            document.cookie = "sa_market_id={app_id}; Secure";
            window.location = '{callback_url}?' + query;
        }}

        document.addEventListener('musickitloaded', async function () {{
            const dev_token_data = await fetch('{dt_url}', {{
                method: "GET",
                mode: "same-origin",
                cache: "no-cache",
                credentials: "same-origin",
                headers: {{
                    "Content-Type": "application/json",
                }},
                redirect: "follow",
                referrerPolicy: "no-referrer",
            }});

            const dev_token = await dev_token_data.json();

            await MusicKit.configure({{
                developerToken: dev_token['token'],
                app: {{
                    name: 'Playlist sync',
                    build: '1.0.0',
                }}
            }});
            console.log('MusicKit loaded');

            document.getElementById("unauth_btn").addEventListener("click", async function (e) {{
                const music = MusicKit.getInstance();
                music.unauthorize();
            }});

            document.getElementById("auth_btn").addEventListener("click", async function (e) {{
                const music = MusicKit.getInstance();
                try {{
                    const token = await music.authorize();
                    redirect({{'code': token}});
                }} catch (exp) {{
                    redirect({{'error': exp.message}});
                }}
            }});

        }});
    </script>
    </body>
    </html>
    """
    return Response(body=data, headers={"Content-Type": "text/html"})


@api_handler
@docs(tags=("service_accounts",), summary="Get extra info about service accounts")
@querystring_schema(ExtraInfoRequestSchema)
@response_schema(code=NotFound.status_code, description="Unknown service account")
@response_schema(code=Unauthorized.status_code, description="Unauthorized")
@response_schema(code=BadRequest.status_code, description="BadRequest")
@response_schema(ExtraInfoResponseSchema(many=True), description="List of extra infos")
def get_account_extras(request: Request, logger: BoundLogger) -> Response:
    params = ExtraInfoRequestSchema().load(request.multi_value_query_parameters)

    ids = []
    for values in params.items():
        if isinstance(values, list):
            ids.extend(values)

    service = ServiceAccountService()
    service_accounts = service.select_by_user_id(*ids)

    if params["extra"]:
        infos = []
        for service_account in service_accounts:
            api_client = get_authorized_api_client(service_account, logger)
            if api_client is None:
                raise NotFound(f"Unknown service account '{service_account.user_identifier}'")

            infos.append(api_client.get_user_info().to_dict())
    else:
        infos = service_accounts

    return Response(ExtraInfoResponseSchema(many=True).dumps(infos))