#!/usr/bin/env python3.12
# pylint: disable=bare-except, broad-exception-caught, wrong-import-order
# pylint: disable=wrong-import-position


import logging
import traceback
import json
import sys
sys.path.insert(1,'..')
from lyric_search_new import notifier
import redis.asyncio as redis
from redis.commands.search.query import Query
from redis.commands.search.indexDefinition import IndexDefinition, IndexType
from redis.commands.search.field import TextField
from . import private



logger = logging.getLogger()
log_level = logging.getLevelName(logger.level)

class RedisException(Exception):
    """
    Redis Exception
    """

class RedisCache:
    """
    Redis Cache Methods
    """

    def __init__(self):
        self.redis_client = redis.Redis(password=private.REDIS_PW)
        self.notifier = notifier.DiscordNotifier()
        self.notify_warnings = True
    
    async def create_index(self):
        """Create Index"""
        try:
            schema = (
            TextField("$.artist", as_name="artist"),
            TextField("$.song", as_name="song"),
            TextField("$.src", as_name="src"),
            TextField("$.lyrics", as_name="lyrics")
        )    
            result = await self.redis_client.ft().create_index(
                schema, definition=IndexDefinition(prefix=["lyrics:"], index_type=IndexType.JSON))
            if str(result) != "OK":
                raise RedisException(f"Redis: Failed to create index: {result}")
        except Exception as e:
            await self.notifier.send(f"ERROR @ {__file__}", f"Failed to create idx: {str(e)}")

    async def search(self, **kwargs):
        """
        Search Redis Cache
        Args:
            artist (Optional[str]): artist to search
            song (Optional[str]): song to search
            lyrics (Optional[str]): lyrics to search (optional, used in place of artist/song if provided)
        Returns:
            list[tuple]: List of redis results, tuple's first value is the redis key, second is the returned data
        """

        try:
            artist = kwargs.get('artist', '')
            song = kwargs.get('song', '')
            lyrics = kwargs.get('lyrics')
            is_random_search = artist == "!" and song == "!"

            if lyrics:
                # to code later
                raise RedisException("Lyric search not yet implemented")
            
            if not is_random_search:
                artist = artist.replace("-", " ")
                song = song.replace("-", " ")
                search_res = await self.redis_client.ft().search(
                    Query(f"@artist:{artist} @song:{song}"
                          )) 
                search_res_out = [(result['id'].split(":",
                                                      maxsplit=1)[1], dict(json.loads(result['json'])))
                                  for result in search_res.docs]
            else:
                random_redis_key = await self.redis_client.randomkey()
                out_id = str(random_redis_key).split(":",
                                                     maxsplit=1)[1][:-1]
                search_res = await self.redis_client.json().get(random_redis_key)
                search_res_out = [(out_id, search_res)]

            if not search_res_out and self.notify_warnings:
                await self.notifier.send("WARNING", f"Redis cache miss for: \n## *{artist} - {song}*")
            return search_res_out
        except Exception as e:
            await self.notifier.send(f"ERROR @ {__file__}", str(e))
            traceback.print_exc()