from typing import List, Dict, Optional, Tuple
import random
import difflib
from rapidfuzz import fuzz
import sqlite3
import functools
from const import KNOWLEDGE_TO_SELECT, UTTERANCE, ROLES, BELIEF_STATE, DOMAIN


def None_knowledge():
    return "None"


def concat_list_knowledge_wrapper(prompt: str = "", sep: str = " | "):
    def get_list_knowledge(str_list: List[str]):
        return prompt + sep.join(str_list)

    return get_list_knowledge


def origin_knowledge(knowledge):
    return knowledge


def extract_turn_knowledge(
    knowledge, section_prompt_op, section_sep, section_value_sep
):
    if isinstance(knowledge, dict):
        sec_list = []
        for section in sorted(knowledge.keys()):
            sec_str = f"{section}{section_prompt_op}"
            if isinstance(knowledge[section], str):
                sec_str += knowledge[section]
            elif isinstance(knowledge[section], list):
                sec_str += section_value_sep.join(knowledge[section])
            sec_list.append(sec_str)

        return section_sep.join(sec_list)

    elif isinstance(knowledge, str):
        return knowledge

    elif isinstance(knowledge, list):
        return ";; ".join(
            [
                extract_turn_knowledge(
                    sec, section_prompt_op, section_sep, section_value_sep
                )
                for sec in knowledge
            ]
        )


def extract_turn_domains_wrapper(prompt: str = "", sep: str = ", "):
    def extract_turn_domains(knowledge, turn):
        bs = turn[BELIEF_STATE]
        domains = []
        for state in bs:
            domain = state[DOMAIN]
            if domain not in domains:
                domains.append(domain)

        return prompt + sep.join(domains)

    return extract_turn_domains


def extract_turn_knowledge_wrapper(section_prompt_op, section_sep, section_value_sep):
    def extract_turn_knowledge_func(knowledge, turn):
        return extract_turn_knowledge(
            [knowledge[sec] for sec in turn[KNOWLEDGE_TO_SELECT]],
            section_prompt_op,
            section_sep,
            section_value_sep,
        )

    return extract_turn_knowledge_func


# Text2SQL
EXIST = {"atis", "geo", "advising", "yelp", "restaurants", "imdb", "academic"}

# fmt: off
_stopwords = {'who', 'ourselves', 'down', 'only', 'were', 'him', 'at', "weren't", 'has', 'few', "it's", 'm', 'again',
              'd', 'haven', 'been', 'other', 'we', 'an', 'own', 'doing', 'ma', 'hers', 'all', "haven't", 'in', 'but',
              "shouldn't", 'does', 'out', 'aren', 'you', "you'd", 'himself', "isn't", 'most', 'y', 'below', 'is',
              "wasn't", 'hasn', 'them', 'wouldn', 'against', 'this', 'about', 'there', 'don', "that'll", 'a', 'being',
              'with', 'your', 'theirs', 'its', 'any', 'why', 'now', 'during', 'weren', 'if', 'should', 'those', 'be',
              'they', 'o', 't', 'of', 'or', 'me', 'i', 'some', 'her', 'do', 'will', 'yours', 'for', 'mightn', 'nor',
              'needn', 'the', 'until', "couldn't", 'he', 'which', 'yourself', 'to', "needn't", "you're", 'because',
              'their', 'where', 'it', "didn't", 've', 'whom', "should've", 'can', "shan't", 'on', 'had', 'have',
              'myself', 'am', "don't", 'under', 'was', "won't", 'these', 'so', 'as', 'after', 'above', 'each', 'ours',
              'hadn', 'having', 'wasn', 's', 'doesn', "hadn't", 'than', 'by', 'that', 'both', 'herself', 'his',
              "wouldn't", 'into', "doesn't", 'before', 'my', 'won', 'more', 'are', 'through', 'same', 'how', 'what',
              'over', 'll', 'yourselves', 'up', 'mustn', "mustn't", "she's", 're', 'such', 'didn', "you'll", 'shan',
              'when', "you've", 'themselves', "mightn't", 'she', 'from', 'isn', 'ain', 'between', 'once', 'here',
              'shouldn', 'our', 'and', 'not', 'too', 'very', 'further', 'while', 'off', 'couldn', "hasn't", 'itself',
              'then', 'did', 'just', "aren't"}
# fmt: on

_commonwords = {"no", "yes", "many"}


def is_number(s: str) -> bool:
    try:
        float(s.replace(",", ""))
        return True
    except:
        return False


def is_stopword(s: str) -> bool:
    return s.strip() in _stopwords


def is_commonword(s: str) -> bool:
    return s.strip() in _commonwords


def is_common_db_term(s: str) -> bool:
    return s.strip() in ["id"]


class Match(object):
    def __init__(self, start: int, size: int) -> None:
        self.start = start
        self.size = size


def is_span_separator(c: str) -> bool:
    return c in "'\"()`,.?! "


def split(s: str) -> List[str]:
    return [c.lower() for c in s.strip()]


def prefix_match(s1: str, s2: str) -> bool:
    i, j = 0, 0
    for i in range(len(s1)):
        if not is_span_separator(s1[i]):
            break
    for j in range(len(s2)):
        if not is_span_separator(s2[j]):
            break
    if i < len(s1) and j < len(s2):
        return s1[i] == s2[j]
    elif i >= len(s1) and j >= len(s2):
        return True
    else:
        return False


def get_effective_match_source(s: str, start: int, end: int) -> Match:
    _start = -1

    for i in range(start, start - 2, -1):
        if i < 0:
            _start = i + 1
            break
        if is_span_separator(s[i]):
            _start = i
            break

    if _start < 0:
        return None

    _end = -1
    for i in range(end - 1, end + 3):
        if i >= len(s):
            _end = i - 1
            break
        if is_span_separator(s[i]):
            _end = i
            break

    if _end < 0:
        return None

    while _start < len(s) and is_span_separator(s[_start]):
        _start += 1
    while _end >= 0 and is_span_separator(s[_end]):
        _end -= 1

    return Match(_start, _end - _start + 1)


def get_matched_entries(
    s: str, field_values: List[str], m_theta: float = 0.85, s_theta: float = 0.85
) -> Optional[List[Tuple[str, Tuple[str, str, float, float, int]]]]:
    if not field_values:
        return None

    if isinstance(s, str):
        n_grams = split(s)
    else:
        n_grams = s

    matched = dict()
    for field_value in field_values:
        if not isinstance(field_value, str):
            continue
        fv_tokens = split(field_value)
        sm = difflib.SequenceMatcher(None, n_grams, fv_tokens)
        match = sm.find_longest_match(0, len(n_grams), 0, len(fv_tokens))
        if match.size > 0:
            source_match = get_effective_match_source(
                n_grams, match.a, match.a + match.size
            )
            if source_match and source_match.size > 1:
                match_str = field_value[match.b : match.b + match.size]
                source_match_str = s[
                    source_match.start : source_match.start + source_match.size
                ]
                c_match_str = match_str.lower().strip()
                c_source_match_str = source_match_str.lower().strip()
                c_field_value = field_value.lower().strip()
                if (
                    c_match_str
                    and not is_number(c_match_str)
                    and not is_common_db_term(c_match_str)
                ):
                    if (
                        is_stopword(c_match_str)
                        or is_stopword(c_source_match_str)
                        or is_stopword(c_field_value)
                    ):
                        continue
                    if c_source_match_str.endswith(c_match_str + "'s"):
                        match_score = 1.0
                    else:
                        if prefix_match(c_field_value, c_source_match_str):
                            match_score = (
                                fuzz.ratio(c_field_value, c_source_match_str) / 100
                            )
                        else:
                            match_score = 0
                    if (
                        is_commonword(c_match_str)
                        or is_commonword(c_source_match_str)
                        or is_commonword(c_field_value)
                    ) and match_score < 1:
                        continue
                    s_match_score = match_score
                    if match_score >= m_theta and s_match_score >= s_theta:
                        if field_value.isupper() and match_score * s_match_score < 1:
                            continue
                        matched[match_str] = (
                            field_value,
                            source_match_str,
                            match_score,
                            s_match_score,
                            match.size,
                        )

    if not matched:
        return None
    else:
        return sorted(
            matched.items(),
            key=lambda x: (1e16 * x[1][2] + 1e8 * x[1][3] + x[1][4]),
            reverse=True,
        )


@functools.lru_cache(maxsize=1000, typed=False)
def get_column_picklist(table_name: str, column_name: str, db_path: str) -> list:
    fetch_sql = "SELECT DISTINCT `{}` FROM `{}`".format(column_name, table_name)
    try:
        conn = sqlite3.connect(db_path)
        conn.text_factory = bytes
        c = conn.cursor()
        c.execute(fetch_sql)
        picklist = set()
        for x in c.fetchall():
            if isinstance(x[0], str):
                picklist.add(x[0].encode("utf-8"))
            elif isinstance(x[0], bytes):
                try:
                    picklist.add(x[0].decode("utf-8"))
                except UnicodeDecodeError:
                    picklist.add(x[0].decode("latin-1"))
            else:
                picklist.add(x[0])
        picklist = list(picklist)
    finally:
        conn.close()
    return picklist


def get_database_matches(
    question: str,
    table_name: str,
    column_name: str,
    db_path: str,
    top_k_matches: int = 2,
    match_threshold: float = 0.85,
) -> List[str]:
    picklist = get_column_picklist(
        table_name=table_name, column_name=column_name, db_path=db_path
    )
    matches = []
    if picklist and isinstance(picklist[0], str):
        matched_entries = get_matched_entries(
            s=question,
            field_values=picklist,
            m_theta=match_threshold,
            s_theta=match_threshold,
        )
        if matched_entries:
            num_values_inserted = 0
            for _match_str, (
                field_value,
                _s_match_str,
                match_score,
                s_match_score,
                _match_size,
            ) in matched_entries:
                if "name" in column_name and match_score * s_match_score < 1:
                    continue
                if table_name != "sqlite_sequence":  # Spider database artifact
                    matches.append(field_value)
                    num_values_inserted += 1
                    if num_values_inserted >= top_k_matches:
                        break
    return matches


def serialize_schema(
    question: str,
    db_path: str,
    db_id: str,
    db_column_names: Dict[str, str],
    db_table_names: List[str],
    schema_serialization_type: str = "peteshaw",
    schema_serialization_randomized: bool = False,
    schema_serialization_with_db_id: bool = True,
    schema_serialization_with_db_content: bool = False,
    normalize_query: bool = True,
) -> str:
    if schema_serialization_type == "verbose":
        db_id_str = "Database: {db_id}. "
        table_sep = ". "
        table_str = "Table: {table}. Columns: {columns}"
        column_sep = ", "
        column_str_with_values = "{column} ({values})"
        column_str_without_values = "{column}"
        value_sep = ", "
    elif schema_serialization_type == "peteshaw":
        # see https://github.com/google-research/language/blob/master/language/nqg/tasks/spider/append_schema.py#L42
        db_id_str = "{db_id}"
        table_sep = ""
        table_str = " | {table} : {columns}"
        column_sep = " , "
        column_str_with_values = "{column} ( {values} )"
        column_str_without_values = "{column}"
        value_sep = " , "
    else:
        raise NotImplementedError

    def get_column_str(table_name: str, column_name: str) -> str:
        column_name_str = column_name.lower() if normalize_query else column_name
        if schema_serialization_with_db_content:
            matches = get_database_matches(
                question=question,
                table_name=table_name,
                column_name=column_name,
                db_path=(db_path + "/" + db_id + "/" + db_id + ".sqlite"),
            )
            if matches:
                return column_str_with_values.format(
                    column=column_name_str, values=value_sep.join(matches)
                )
            else:
                return column_str_without_values.format(column=column_name_str)
        else:
            return column_str_without_values.format(column=column_name_str)

    tables = [
        table_str.format(
            table=table_name.lower() if normalize_query else table_name,
            columns=column_sep.join(
                map(
                    lambda y: get_column_str(table_name=table_name, column_name=y[1]),
                    filter(
                        lambda y: y[0] == table_id,
                        zip(
                            db_column_names["table_id"],
                            db_column_names["column_name"],
                        ),
                    ),
                )
            ),
        )
        for table_id, table_name in enumerate(db_table_names)
    ]
    if schema_serialization_randomized:
        random.shuffle(tables)
    if schema_serialization_with_db_id:
        serialized_schema = db_id_str.format(db_id=db_id) + table_sep.join(tables)
    else:
        serialized_schema = table_sep.join(tables)
    return serialized_schema


def extract_schema_knowledge_wrapper(
    schema_serialization_type: str = "peteshaw",
    schema_serialization_randomized: bool = False,
    schema_serialization_with_db_id: bool = True,
    schema_serialization_with_db_content: bool = False,
    normalize_query: bool = True,
):
    def extract_turn_schema_knowledge_func(knowledge, turn):
        schema = knowledge["schema"]
        db_column_names = {
            "table_id": [table_id for table_id, _ in schema["column_names_original"]],
            "column_name": [
                column_name for _, column_name in schema["column_names_original"]
            ],
        }
        return serialize_schema(
            turn[UTTERANCE],
            knowledge["db_path"],
            knowledge["db_id"],
            db_column_names,
            schema["table_names_original"],
            schema_serialization_type,
            schema_serialization_randomized,
            schema_serialization_with_db_id,
            schema_serialization_with_db_content,
            normalize_query,
        )

    return extract_turn_schema_knowledge_func


def extract_dict_knowledge(knowledge, key_prompt_op, pair_sep):
    pair_list = []
    for key in knowledge:
        pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}")

    if not pair_list:
        return "None"

    return pair_sep.join(pair_list)


def extract_dict_knowledge_wrapper(key_prompt_op, pair_sep):
    def extract_dict_knowledge_func(knowledge):
        return extract_dict_knowledge(knowledge, key_prompt_op, pair_sep)

    return extract_dict_knowledge_func


def extract_dialogue_knowledge(knowledge, key_prompt_op, pair_sep, role_sep):
    pair_list = []
    for key in knowledge:
        if isinstance(knowledge[key], str):
            pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}")
        elif isinstance(knowledge[key], list):
            turns = []
            for turn in knowledge[key]:
                role_str = role_sep.join(turn[ROLES])
                turns.append(f"{role_str}# {turn[UTTERANCE]}")
            dial_str = " ".join(turns)
            pair_list.append(f"{key}{key_prompt_op}{dial_str}")
    if not pair_list:
        return "None"
    return pair_sep.join(pair_list)


def extract_dialogue_knowledge_wrapper(key_prompt_op, pair_sep, role_sep):
    def extract_dialogue_knowledge_func(knowledge):
        return extract_dialogue_knowledge(knowledge, key_prompt_op, pair_sep, role_sep)

    return extract_dialogue_knowledge_func


def extract_kg_knowledge(
    knowledge, key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep
):
    pair_list = []
    for key in knowledge:
        if isinstance(knowledge[key], str):
            pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}")
        elif isinstance(knowledge[key], list):
            edges = []
            for edge in knowledge[key]:
                edges.append(inner_edge_sep.join(edge))
            kg_str = intra_edge_sep.join(edges)
            pair_list.append(f"{key}{key_prompt_op}{kg_str}")
    if not pair_list:
        return "None"
    return pair_sep.join(pair_list)


def extract_kg_knowledge_wrapper(
    key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep
):
    def extract_kg_knowledge_func(knowledge):
        return extract_kg_knowledge(
            knowledge, key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep
        )

    return extract_kg_knowledge_func