"""Stateless, signed conversation references; source text is never chat memory.

The caller explicitly returns a token from its own previous tool response. No
global last-person/last-meeting state is kept, and nothing is written to wiki.
"""
from __future__ import annotations

import base64
from dataclasses import dataclass
import hashlib
import hmac
import json
import os
import re
import time

from tools.answers.context_policy import normalized
from tools.answers.question_intent import normalize_question
from tools.answers.question_plan import MeetingRequest, direct_spec
from tools.retrieval.person_names import resolve_person_names

MAX_TOKEN = 16000
LIFETIME = 24 * 60 * 60
MEETING_REF = re.compile(r'\b(?:vtedy|(?:v|na|o|z|pri) (?:danom|tomto|tom|tomto istom) stretnuti)\b')
WORK_REF = re.compile(r'\b(?:(?:tej|tu|t[uú]) (?:druhej|druhu|prvej|prvu)|(?:pri|o) druhej) (?:praci|pracu|projekte)\b')
# A pronoun points at the previous person ("Kto bol jeho vedúci?", "Aké výsledky dosiahla?" is no pronoun).
PRONOUN_REF = re.compile(r'\b(?:jeho|jej|ho|mu|nemu|nej|nom|onej|on|ona|tento student|tato studentka|ten student|'
                         r'ta studentka|toho studenta|tej studentky|ten isty|ta ista|daneho studenta|danej studentky|'
                         r'tohto studenta|tejto studentky)\b')
# A short question made only of these words asks about an aspect of the previous subject
# ("Kto bol vedúci?", "Aké technológie použil?"); any other content word makes it a new question.
ASPECT_WORDS = set("""kto bol bola boli je su bude co aky aka ake akej akom akych ktory ktora ktore kedy kde ako kolko
mal mala mali ma maju robil robila pracoval pracovala pouzil pouzila pouzival pouzivala dosiahol dosiahla urobil
urobila napisal napisala veduci veduceho veducim skolitel skolitela konzultant konzultanta oponent oponenta vysledky
vysledok vysledkoch technologie technologiu nastroje nastroj metody metodu ciel ciele tema temu temy nazov nazvy
praca prace pracu praci rok roku roky stretnutie stretnutia stretnuti posledne prve ulohy ulohu stav pokrok zadanie
plan klucove slova tagy jazyk jazyky data dataset model modely sa si mu jej jeho ho tam v vo na o z zo s so k a aj ale
uz este teraz potom tiez prosim daj ukaz vypis povedz""".split())
BOTH = re.compile(r'^(?:(?:daj|uved|ukaz|vypis|porovnaj|chcem|prosim)\s+)?(?:obe|oba|obidv\w*)(?:\s+(?:prace|projekty))?[.!?]?$')


class ContextError(ValueError):
    pass


@dataclass
class ResolvedQuestion:
    query: str
    meeting: MeetingRequest | None = None
    clarification: str | None = None
    reason: str | None = None


def _key():
    # Domain-separated from API authentication; no additional .env secret.
    key = os.getenv('SEARCH_API_KEY', '')
    return hashlib.sha256(('zp-conversation-v1\0'+key).encode()).digest() if key else None


def _encode(value):
    return base64.urlsafe_b64encode(value).decode().rstrip('=')


def _decode(value):
    return base64.b64decode(value+'='*(-len(value)%4),altchars=b'-_',validate=True)


def seal(payload):
    key = _key()
    if key is None:
        return None  # Local library tests need no private API configuration.
    body = _encode(json.dumps(payload,ensure_ascii=False,separators=(',',':')).encode())
    token = body+'.'+_encode(hmac.digest(key,body.encode(),'sha256'))
    return token if len(token)<=MAX_TOKEN else None


def unseal(token, version):
    try:
        if not isinstance(token,str) or not 1<=len(token)<=MAX_TOKEN or _key() is None:
            raise ValueError()
        body,signature=token.split('.')
        if not hmac.compare_digest(_decode(signature),hmac.digest(_key(),body.encode(),'sha256')):
            raise ValueError()
        value=json.loads(_decode(body))
        if value.get('schema')!=1 or not isinstance(value.get('question'),str):raise ValueError()
        if value['expires']<time.time():raise ContextError('expired_context')
        if value['version']!=(version or {}).get('version'):raise ContextError('stale_context')
        return value
    except ContextError:
        raise
    except (ValueError,KeyError,TypeError,UnicodeError):
        raise ContextError('invalid_context') from None


def _options(index, spec):
    people={p.name for p in spec.people if p.role=='student'}
    rows=[r for r in (index or {}).get('units',[]) if r['person'] in people and
          spec.matches_work(r['person'],r.get('work_label'),r.get('work_type'),r.get('work_year'))]
    works=[];seen=set()
    for r in rows:
        if r.get('work_id') and r['work_id'] not in seen:
            seen.add(r['work_id'])
            works.append({'person':r['person'],'id':r['work_id'],'label':r['work_label']})
    return works, [r for r in rows if r['kind']=='meeting']


def issue_context(question, result, catalog, index, version):
    if result.get('accepted_for_delivery') is not True or result.get('status') not in {'ok','ambiguous'}:
        return None
    if result.get('index_version')!=version or index is None:return None
    resolution=resolve_person_names(question,catalog)
    if resolution['status']=='ambiguous' and result.get('status')=='ambiguous' and resolution.get('candidates'):
        # "Ktorého Jána myslíš?" -> the next reply "Ján Holp" answers THIS
        # question. Only catalog choices actually offered can be selected.
        options=list(dict.fromkeys(c['name'] for c in resolution['candidates']))
        if not 2<=len(options)<=20:return None
        payload={'schema':1,'version':version['version'],'expires':int(time.time())+LIFETIME,
                 'question':question,'people':[],'works':[],'meetings':[],
                 'pending_person':{'mention':resolution['mention'],'options':options}}
        token=seal(payload)
        return {'token':token,'work_options':[],'meeting_options':[],'person_options':options} if token else None
    if resolution['status']!='ok':return None
    spec=direct_spec(question,resolution)
    works,markers=_options(index,spec)
    if not spec.people:return None
    # Options must follow the displayed order, particularly numbered choices.
    answer=normalized(result.get('answer',''))
    if result.get('status')=='ok':
        shown=[w for w in works if normalized(w['label']) in answer]
        if shown:works=shown
    works.sort(key=lambda w:answer.find(normalized(w['label'])) if normalized(w['label']) in answer else len(answer))
    evidence=result.get('evidence',[])
    focused={r.get('meeting_id') or (r.get('id') if r.get('kind')=='meeting' else None) for r in evidence}
    meetings=[{'id':r['id'],'person':r['person'],'work_id':r.get('work_id'),
               'label':r.get('work_label'),'date':r.get('date'),'date_label':r.get('date_label')}
              for r in markers if (r.get('meeting_id') or r['id']) in focused]
    if spec.meeting and spec.meeting.selection=='latest' and any(m['date'] for m in meetings):
        dates=sorted({m['date'] for m in meetings if m['date']},reverse=True)[:spec.meeting.count]
        meetings=[m for m in meetings if m['date'] in dates]
    # Include exact source-backed options in a clarification, never every
    # meeting as if it had already been selected by a successful answer.
    if not meetings and result.get('reason')=='missing_meeting_context':
        meetings=[{'id':r['id'],'person':r['person'],'work_id':r.get('work_id'),
                   'label':r.get('work_label'),'date':r.get('date'),'date_label':r.get('date_label')}
                  for r in markers[:12]]
    if len(works)>20 or len(meetings)>12:return None
    payload={'schema':1,'version':version['version'],'expires':int(time.time())+LIFETIME,
             'question':question,'people':[p.model_dump() for p in spec.people],
             'works':works,'meetings':meetings}
    token=seal(payload)
    return {'token':token,'work_options':works,'meeting_options':meetings} if token else None


def resolve_question(question, *, token=None, catalog, index, version):
    query=normalize_question(question)
    n=normalized(query)
    context=unseal(token,version) if token else None
    if context and context.get('pending_person'):
        chosen=_chosen_person(query,context['pending_person'],catalog)
        if chosen:
            original=context['question']
            mention=context['pending_person']['mention']
            resolved=re.sub(r'(?<!\w)'+re.escape(mention)+r'(?!\w)',chosen,original,count=1)
            return ResolvedQuestion(resolved if resolved!=original else original.rstrip(' ?.')+' Osoba: '+chosen+'.')
        # Anything else is a new, independent question.
        return ResolvedQuestion(query)
    year_followup=re.fullmatch(r'(?:(?:a|ale)(?: co)?\s+)?v roku ([12]\d{3})[.?]?',n)
    if context and year_followup:
        old=direct_spec(context['question'],resolve_person_names(context['question'],catalog))
        if old.intent=='meeting' and old.meeting and old.meeting.selection=='latest':
            query=re.sub(r'\bv roku [12]\d{3}\b','',context['question'],flags=re.I).rstrip(' .?')+' v roku '+year_followup[1]+'?'
            n=normalized(query)
    meeting_ref=bool(MEETING_REF.search(n))
    work_ref=WORK_REF.search(n)
    both=bool(BOTH.fullmatch(n))
    explicit_date=bool(re.search(r'\b\d{1,2}\.\s*\d{1,2}\.\s*[12]\d{3}\b',query))
    # An explicit date is stronger than a redundant word such as "vtedy".
    needs_context=meeting_ref and not explicit_date or bool(work_ref) or both
    aspect_only=bool(n) and len(n.split())<=7 and all(w in ASPECT_WORDS or w.isdigit() for w in n.split())
    short_followup=bool(context and (explicit_date or re.match(r'^(?:a |ale |čo |co |aké |ake |kedy |čo sa |co sa )',n)
                                     or PRONOUN_REF.search(n) or aspect_only))
    if needs_context and context is None:
        return ResolvedQuestion(query,clarification=(
            'Ktoré stretnutie máš na mysli? Uveď študenta a dátum alebo presné označenie stretnutia.' if meeting_ref
            else 'Ktoré práce máš na mysli? Uveď osobu a presné označenia prác.'),
            reason='missing_meeting_context' if meeting_ref else 'missing_followup_context')
    if not context or not (needs_context or short_followup):return ResolvedQuestion(query)
    # Revalidate references against the captured published generation, not just
    # a plausible name, an unsigned caller dictionary or a model's assertions.
    by_id={r['id']:r for r in (index or {}).get('units',[])}
    for marker in context['meetings']:
        row=by_id.get(marker['id'])
        if not row or row['kind']!='meeting' or row['person']!=marker['person'] or row.get('work_id')!=marker['work_id']:
            raise ContextError('invalid_context')
    for work in context['works']:
        if not any(r.get('work_id')==work['id'] and r['person']==work['person'] and r.get('work_label')==work['label'] for r in by_id.values()):
            raise ContextError('invalid_context')
    # A verified relative reference is a grammatical slot, not a person mention.
    # Resolve identities outside that slot (e.g. "danom" can also resemble an
    # inflection of a real given name). The original query is kept unchanged.
    identity_query=MEETING_REF.sub(' ',n) if meeting_ref else query
    actual=resolve_person_names(identity_query,catalog)
    if actual['status']!='ok':return ResolvedQuestion(query)
    named=[m['name'] for m in actual.get('matches',[])]
    previous={p['name'] for p in context['people']}
    if needs_context and named and not set(named)<=previous:
        return ResolvedQuestion(query,clarification='Odkaz patrí k inej osobe. Uveď pre aktuálneho študenta konkrétnu prácu alebo dátum stretnutia.',reason='context_subject_mismatch')
    if both or work_ref:
        works=context['works']
        if both and len(works)!=2 or work_ref and len(works)<2:
            return ResolvedQuestion(query,clarification='Predchádzajúce možnosti neurčujú jednoznačný výber. Uveď presné názvy požadovaných prác.',reason='ambiguous_work_reference')
        chosen=works if both else [works[0 if 'prv' in work_ref[0] else 1]]
        if len({w['person'] for w in chosen})!=1:
            return ResolvedQuestion(query,clarification='Uveď osobu a presné označenie každej vyberanej práce.',reason='ambiguous_work_reference')
        selection_only=bool(work_ref and WORK_REF.sub('',n).strip(' .?!') in {'','pri','o','daj','ukaz'})
        if both or selection_only:
            from tools.retrieval.work_selector import QUOTED,label_key
            old_labels={label_key(w['label']) for w in works}
            query=QUOTED.sub(lambda m:'' if label_key(m[1]) in old_labels else m[0],context['question'])
        else:
            query=re.sub(r'\b(?:pri\s+)?(?:tej\s+)?(?:druhej|prvej)\s+(?:práci|praci|projekte)\b',
                         'pri vybranej práci',query,flags=re.I)
        query+=' Pýtam sa na '+('obe práce: ' if both else 'prácu: ')+ ' aj '.join('"'+w['label']+'"' for w in chosen)+'.'
        if not named and not (both or selection_only):query+=' Osoba: '+chosen[0]['person']+'.'
    elif not named and len(previous)==1:
        if re.fullmatch(r'\d{1,2}\.\s*\d{1,2}\.\s*[12]\d{3}[.?]?',query):
            query='Na čom pracoval na stretnutí '+query.rstrip('?')+'?'
        person=context['people'][0]
        prefix={'supervisor':'Pod vedením ','consultant':'Konzultant ',
                'document_author':'Autor dokumentu '}.get(person['role'],'Osoba: ')
        query+=' '+prefix+person['name']+'.'
    elif not named and previous:
        return ResolvedQuestion(query,clarification='Na ktorú z predchádzajúcich osôb otázka nadväzuje? Uveď celé meno.',reason='ambiguous_person_reference')
    meeting=None
    from tools.retrieval.question_constraints import requested_years
    inherited_meeting=bool(not named and not explicit_date and not requested_years(question) and not work_ref and not both and short_followup
        and context['meetings'] and direct_spec(context['question'],resolve_person_names(context['question'],catalog)).intent=='meeting')
    if (meeting_ref or inherited_meeting) and not explicit_date:
        markers=context['meetings']
        if len(markers)!=1:
            options='; '.join(m['person']+' — '+str(m['label'])+' — '+str(m['date'] or m['date_label']) for m in markers)
            return ResolvedQuestion(query,clarification='Ktoré stretnutie máš na mysli? '+(options+'. ' if options else '')+'Uveď konkrétny dátum alebo označenie.',reason='ambiguous_meeting_reference')
        marker=markers[0]
        meeting=MeetingRequest(selection='exact',ids=[by_id[marker['id']].get('meeting_id') or marker['id']])
        label=marker['date'] or marker['date_label']
        if marker['date']:
            y,m,d=marker['date'].split('-');label=f'{int(d)}.{int(m)}.{y}'
        # Match on original Unicode spelling without replacing unrelated words.
        query=re.sub(r'\bvtedy\b|\b(?:v|na|o|z|pri)\s+(?:danom|tomto|tom|tomto istom)\s+stretnut[ií]\b',
                     'na stretnutí '+label,query,flags=re.I)
        if inherited_meeting:query+=' Na stretnutí '+label+'.'
        query+=' Pri práci "'+marker['label']+'".' if marker['label'] else ''
    if not both and meeting is None and len(previous)==1 and not named:
        query=_inherit_constraints(query,context,catalog)
    if len(query)>500:
        return ResolvedQuestion(query,clarification='Nadväzujúca otázka je príliš dlhá. Uveď stručne osobu, prácu, dátum a požadovanú informáciu.',reason='resolved_query_too_long')
    return ResolvedQuestion(query,meeting=meeting)


def _chosen_person(query, pending, catalog):
    """A short reply that names exactly one of the offered people."""
    options=pending.get('options') or []
    if not isinstance(options,list) or not all(isinstance(o,str) for o in options):return None
    resolution=resolve_person_names(query,[row for row in catalog if row.get('name') in options])
    if resolution['status']!='ok':return None
    chosen={m['name'] for m in resolution.get('matches',[])}&set(options)
    if len(chosen)!=1:return None
    name=chosen.pop()
    rest=normalized(query)
    for match in resolution['matches']:
        rest=rest.replace(normalized(match['input']),' ')
    # "Ján Holp", "toho Holpa", "myslím Jána Holpa, prosím" select; a long
    # new sentence that happens to contain the name is a new question.
    filler={'myslim','mam','na','mysli','toho','tu','teho','prosim','ano','ten','ta','to','je','sa','pytam','na','osobu','studenta'}
    return name if len([w for w in rest.split() if w not in filler])<=1 else None


def _inherit_constraints(query, context, catalog):
    """Carry previous explicit constraints, allowing explicit new replacements."""
    from tools.answers.rag_evidence import WORK_LABELS
    old=direct_spec(context['question'],resolve_person_names(context['question'],catalog))
    new=direct_spec(query,resolve_person_names(query,catalog))
    if len(old.people)!=1:return query
    prior=old.works[0] if old.works else None
    current=new.works[0] if new.works else None
    if prior and current:
        if not (current.work_type or current.labels or current.numbers):
            if prior.labels:query+=' Pri práci '+ ' alebo '.join('"'+v+'"' for v in prior.labels)+'.'
            elif prior.work_type:query+=' Typ práce: '+WORK_LABELS[prior.work_type]+'.'
        if prior.years and not new.years and new.period is None:
            query+=' Rok práce: '+', '.join(str(y) for y in prior.years)+'.'
        if prior.excluded_labels and not current.excluded_labels:
            query+=' Nie '+ ' ani '.join('"'+v+'"' for v in prior.excluded_labels)+'.'
    for condition in old.conditions:
        if condition.kind in {'tag','category','document_author','exclusion','current_status'} and not any(c.kind==condition.kind for c in new.conditions):
            query+=' '+condition.quote+'.'
    if old.period and not new.period:
        def label(value):
            y,m,d=value.split('-');return f'{int(d)}.{int(m)}.{y}'
        query+=' Obdobie od '+label(old.period.start)+' do '+label(old.period.end)+'.'
    return query


def answer_matches_scope(question, result, catalog, meeting=None):
    """Necessary final identity/meeting check, independent of prose quality."""
    if result.get('status')!='ok' or not result.get('accepted_for_delivery'):return True
    resolution=resolve_person_names(question,catalog)
    if resolution['status']!='ok':return False
    spec=direct_spec(question,resolution,meeting=meeting)
    names={p.name for p in spec.people if p.role=='student'}
    rows=result.get('evidence',[])
    if names and spec.intent not in {'similar','discovery'}:
        if any(r.get('person') and r['person'] not in names for r in [*rows,*result.get('claims',[])]):return False
    if spec.meeting:
        if not rows:return False
        if any(not spec.matches_evidence(r) for r in rows):return False
        if spec.period and spec.period.field=='record_date' and any(
                not r.get('record_date') or not spec.period.start<=r['record_date']<=spec.period.end for r in rows):return False
    return True