#!/usr/bin/env python

"""Demonstrates medical term feature generation from spaCy parsed natural

langauge.

This example needs the ``zensols.deepnlp`` library, install with::

    pip install zensols.deepnlp

"""

__author__ = 'Paul Landes'

from typing import Dict, List, Tuple

from dataclasses import dataclass, field

import logging

from gensim.models.keyedvectors import KeyedVectors

from zensols.cli import CliHarness ; CliHarness.add_sys_path('src/python')

from zensols.cli import ProgramNameConfigurator, ApplicationError

from zensols.mednlp import UTSClient

from zensols.mednlp.cui2vec import Cui2VecEmbedModel

logger = logging.getLogger(__name__)

# the definition of the application class executed from the CLI glue code

@dataclass

class Application(object):

    """Demonstrates access to UTS.

    """

    # tell the application not mistake the fields as an option when generating

    # the online help with the -h option

    CLI_META = {'option_excludes': {'uts_client', 'cui2vec_embedding'}}

    uts_client: UTSClient = field()

    """Queries UMLS data."""

    cui2vec_embedding: Cui2VecEmbedModel = field()

    """The cui2vec embedding model."""

    def __post_init__(self):

        # suppress gensim API warnings

        import warnings

        warnings.filterwarnings(

            'ignore', message='invalid value encountered in true_divide')

    @property

    def kv(self) -> KeyedVectors:

        embedding: Cui2VecEmbedModel = self.cui2vec_embedding

        return embedding.keyed_vectors

    def _search_cui(self, term: str) -> str:

        kv: KeyedVectors = self.kv

        res: List[Dict[str, str]] = self.uts_client.search_term(term)

        cui: str = None

        for rd in res:

            cui = rd['ui']

            if cui in kv:

                logger.info(f"found cui: '{term}' -> {cui}")

                break

        if cui is None:

            raise ApplicationError(f'CUI {cui} not found in cui2vec')

        return cui

    def similarity(self, term: str = 'heart disease', topn: int = 5):

        """Get the cosine similarity between two CUIs.

        :param term: the medical term

        :param topn: the top N count similarities to return

        """

        kv: KeyedVectors = self.kv

        cui: str = self._search_cui(term)

        sims_by_word: List[Tuple[str, float]] = kv.similar_by_word(cui, topn)

        for rel_cui, proba in sims_by_word:

            rel_atom: Dict[str, str] = self.uts_client.get_atoms(rel_cui)

            rel_name = rel_atom.get('name', 'Unknown')

            logger.info(f'{rel_name} ({rel_cui}): {proba * 100:.2f}%')

    def distance(self, term_a: str, term_b: str) -> float:

        """Get the cosine similarity between two CUIs.

        :param term: the medical term

        """

        kv: KeyedVectors = self.kv

        cui_a: str = self._search_cui(term_a)

        cui_b: str = self._search_cui(term_b)

        cos_dis: float = kv.distance(cui_a, cui_b)

        logger.info(f'similarity: {cui_a} <-> {cui_b}: {cos_dis}')

        return cos_dis

if (__name__ == '__main__'):

    CliHarness(

        app_config_resource='cui2vec.conf',

        app_config_context=ProgramNameConfigurator(

            None, default='cui2vec').create_section(),

        proto_args='',

        proto_factory_kwargs={'reload_pattern': '^cui2vec'},

    ).run()