"""
Configuration parameters:

    frontend.styles
    path.internal.pages
"""

import sys
import os
import collections

try:
    from rapidfuzz import process, fuzz
    _USING_FUZZYWUZZY=False
except ImportError:
    from fuzzywuzzy import process, fuzz
    _USING_FUZZYWUZZY=True

from config import CONFIG
from .adapter import Adapter
from fmt.internal import colorize_internal

_INTERNAL_TOPICS = [
    ":cht.sh",
    ":bash_completion",
    ":emacs",
    ":emacs-ivy",
    ":firstpage",
    ":firstpage-v1",
    ":firstpage-v2",
    ":fish",
    ":help",
    ":intro",
    ":list",
    ":post",
    ":styles",
    ":styles-demo",
    ":vim",
    ":zsh",
    ]

_COLORIZED_INTERNAL_TOPICS = [
    ':intro',
]

class InternalPages(Adapter):

    _adapter_name = 'internal'
    _output_format = 'ansi'

    def __init__(self, get_topic_type=None, get_topics_list=None):
        Adapter.__init__(self)
        self.get_topic_type = get_topic_type
        self.get_topics_list = get_topics_list

    def _get_stat(self):
        stat = collections.Counter([
            self.get_topic_type(topic)
            for topic in self.get_topics_list()
        ])

        answer = ""
        for key, val in stat.items():
            answer += "%s %s\n" % (key, val)
        return answer

    @staticmethod
    def get_list(prefix=None):
        return _INTERNAL_TOPICS

    def _get_list_answer(self, topic, request_options=None):
        if '/' in topic:
            topic_type, topic_name = topic.split('/', 1)
            if topic_name == ":list":
                topic_list = [x[len(topic_type)+1:]
                              for x in self.get_topics_list()
                              if x.startswith(topic_type + "/")]
                return "\n".join(topic_list)+"\n"

        answer = ""
        if topic == ":list":
            answer = "\n".join(x for x in self.get_topics_list()) + "\n"

        return answer

    def _get_page(self, topic, request_options=None):
        if topic.endswith('/:list') or topic.lstrip('/') == ':list':
            return self._get_list_answer(topic)

        answer = ""
        if topic == ':styles':
            answer = "\n".join(CONFIG["frontend.styles"]) + "\n"
        elif topic == ":stat":
            answer = self._get_stat()+"\n"
        elif topic in _INTERNAL_TOPICS:
            answer = open(os.path.join(CONFIG["path.internal.pages"], topic[1:]+".txt"), "r").read()
            if topic in _COLORIZED_INTERNAL_TOPICS:
                answer = colorize_internal(answer)

        return answer

    def is_found(self, topic):
        return (
            topic in self.get_list()
            or topic.endswith('/:list')
        )

class UnknownPages(InternalPages):

    _adapter_name = 'unknown'
    _output_format = 'text'

    @staticmethod
    def get_list(prefix=None):
        return []

    @staticmethod
    def is_found(topic):
        return True

    def _get_page(self, topic, request_options=None):
        topics_list = self.get_topics_list()
        if topic.startswith(':'):
            topics_list = [x for x in topics_list if x.startswith(':')]
        else:
            topics_list = [x for x in topics_list if not x.startswith(':')]

        if _USING_FUZZYWUZZY:
            possible_topics = process.extract(topic, topics_list, scorer=fuzz.ratio)[:3]
        else:
            possible_topics = process.extract(topic, topics_list, limit=3, scorer=fuzz.ratio)
        possible_topics_text = "\n".join([("    * %s %s" % x) for x in possible_topics])
        return """
Unknown topic.
Do you mean one of these topics maybe?

%s
    """ % possible_topics_text

class Search(Adapter):

    _adapter_name = 'search'
    _output_format = 'text'
    _cache_needed = False

    @staticmethod
    def get_list(prefix=None):
        return []

    def is_found(self, topic):
        return False