import logging
import time

import sentry_sdk
from apollo_main_db.apollo.models import ApolloMarket
from apollo_main_db.spotify.models import SpotifyAvailableChart
from apollo_main_db.apple.models import AppleMusicChart
from sqlalchemy import or_
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from sentry_sdk.utils import BadDsn

from config import Config
from db import session_scope
from redis_db import get_redis_lock


logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
config = Config()

try:
    sentry_sdk.init(dsn=config.SENTRY_DSN, integrations=[AwsLambdaIntegration()])
except BadDsn:
    pass

CHART_TYPE_PLAYLIST = "track_chart_playlist"
GLOBAL_MARKET = "global"
GLOBAL_CODE = "_gl"


def main() -> None:
    """Save users starred tracks streams values for all markets."""

    lock = None

    try:
        if config.REDIS_LOCK_ENABLED:
            lock = get_redis_lock()
            if not lock or not lock.acquire(blocking=False):
                logger.info("Can not get lock")
                return

        logger.info('Start')
        start_time = time.time()

        with session_scope(config) as session:
            logger.info('Retrieve primary markets query.')
            primary_markets = (
                session.query(
                    ApolloMarket.code.label("code"),
                    ApolloMarket.charts_vendors.label("charts_vendors")
                ).filter(ApolloMarket.is_primary.is_(True))
            )
            primary_markets_subquery = primary_markets.subquery()

            logger.info('Retrieve Spotify available charts markets.')
            spotify_available_markets = [q.country_code for q in (
                session.query(
                    SpotifyAvailableChart.market.label("country_code")
                ).filter(
                    SpotifyAvailableChart.list_type_id == 0,
                    SpotifyAvailableChart.time_window_id == 0
                ).outerjoin(
                    primary_markets_subquery,
                    or_(
                        SpotifyAvailableChart.market == primary_markets_subquery.c.code,
                        SpotifyAvailableChart.market == GLOBAL_MARKET
                    )
                ).group_by(
                    SpotifyAvailableChart.market
                )
            )]

            logger.info('Retrieve Apple Music available charts markets.')
            apple_available_markets = [q.country_code for q in (
                session.query(
                    AppleMusicChart.storefront.label("country_code")
                ).filter(
                    AppleMusicChart.chart_name == CHART_TYPE_PLAYLIST
                ).outerjoin(
                    primary_markets_subquery,
                    or_(
                        AppleMusicChart.storefront == primary_markets_subquery.c.code,
                        AppleMusicChart.storefront == GLOBAL_MARKET
                    )
                ).group_by(
                    AppleMusicChart.storefront
                )
            )]

            count, updated_count = 0, 0
            for market_obj in primary_markets.all():
                charts_availability = 0
                country_code = market_obj.code
                market = GLOBAL_MARKET if country_code == "_gl" else country_code

                if market in spotify_available_markets:
                    charts_availability += 2
                if market in apple_available_markets:
                    charts_availability += 1

                if charts_availability != market_obj.charts_vendors:
                    logger.info(f"Market <{country_code}> availability value will be updated: {market_obj.charts_vendors} -> {charts_availability}")
                    session.query(ApolloMarket).filter(ApolloMarket.code == country_code).update({"charts_vendors": charts_availability})
                    updated_count += 1
                count += 1
            session.commit()

        logger.info(f"Finished in {time.time() - start_time} sec.")
        logger.info(f"{count} markets were checked, updated - {updated_count}.")

    except Exception as e:
        sentry_sdk.capture_exception(e)
        raise

    finally:
        if config.REDIS_LOCK_ENABLED and lock and lock.locked():
            lock.release()


if __name__ == '__main__':
    main()