import typing

from api import models, api_errors
from api.api_errors import BadRequestError, NotFoundError
from . import execute_to_dicts
from . import AuthenticatedResource
from flask import request
from tracker import db, whitelist
from sqlalchemy import text

from ..models import full_artist

from tracker.spidering import spider

def get_or_create_arid(id, source):
    if not source:
        raise BadRequestError('"source" is required.')
    if source not in ("tw", "in", "spy", "sc", "a"):
        raise BadRequestError("'{}' is not a valid source".format(source))
    if not id:
        raise BadRequestError('"id" is required.')

    if source == "a":
        artist = db.Session.query(db.Artist).get(id)
        if not artist:
            raise NotFoundError("No artist arid: {}".format(id))

        arid = artist.get_canonical_artist().arid

    else:
        obj = spider.get_object_for_source_and_id(id=id, source=source)
        if not obj:
            raise NotFoundError("No entity found for {}/{}".format(source, id))

        if not obj.arid:
            spider.spider(source, obj, existing_data_only=True)
            db.Session.refresh(obj)

        arid = obj.arid

    return arid



# deprecated:
class MyWhitelist(AuthenticatedResource):

    def _response_data(self, arid):
        return full_artist('a', arid, self.user)

    def delete(self, arid):
        whitelist.remove_from_my_whitelist(self.user.name, arid, self.user.get_all_whitelists())
        return self._response_data(arid)

    def put(self, source, id):
        arid = get_or_create_arid(id, source)
        whitelist.add_to_my_whitelist(self.user.name, arid,  self.user.get_all_whitelists())
        return self._response_data(arid)

    def get(self):
        return {
            "artists": list(whitelist.fetch_my_whitelist(self.user.get_all_whitelists()))
        }


class MyWhitelists(AuthenticatedResource):

    def get(self):
        return {
            "artists": list(
                whitelist.fetch_my_whitelist(
                    self.user.get_all_whitelists(),
                    force_refresh=bool(request.args.get('forceRefresh'))
                )
            )
        }


class ManageWhitelist(AuthenticatedResource):

    def _response_data(self, arid):
        return full_artist('a', arid, self.user)

    def get_id_for_name_or_raise(self, whitelist_name):
        for whitelist in self.user.get_all_whitelists():
            if whitelist.name == whitelist_name:
                return whitelist.id

        raise api_errors.BadRequestError(f"Invalid whitelist '{whitelist_name}'")

    def delete(self, whitelist_name, arid):
        whitelist_id = self.get_id_for_name_or_raise(whitelist_name)
        whitelist.remove_from_my_whitelist(whitelist_id, arid, self.user.get_all_whitelists())
        return self._response_data(arid)

    def put(self, whitelist_name, source, id):
        whitelist_id = self.get_id_for_name_or_raise(whitelist_name)
        arid = get_or_create_arid(id, source)
        whitelist.add_to_my_whitelist(whitelist_id, arid, self.user.get_all_whitelists())
        return self._response_data(arid)