"""Support-inbox triage on BANKING77 (PolyAI, CC BY 4.0): 13,083 real online-banking customer queries, 77 intents.
Intents are mapped to 8 support queues and an urgency flag; a text model is compared with keyword rules."""
import json, re, numpy as np, pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_union
from sklearn.metrics import accuracy_score, f1_score
D = '/workspace/cs7/data/'
NAMES = "activate_my_card age_limit apple_pay_or_google_pay atm_support automatic_top_up balance_not_updated_after_bank_transfer balance_not_updated_after_cheque_or_cash_deposit beneficiary_not_allowed cancel_transfer card_about_to_expire card_acceptance card_arrival card_delivery_estimate card_linking card_not_working card_payment_fee_charged card_payment_not_recognised card_payment_wrong_exchange_rate card_swallowed cash_withdrawal_charge cash_withdrawal_not_recognised change_pin compromised_card contactless_not_working country_support declined_card_payment declined_cash_withdrawal declined_transfer direct_debit_payment_not_recognised disposable_card_limits edit_personal_details exchange_charge exchange_rate exchange_via_app extra_charge_on_statement failed_transfer fiat_currency_support get_disposable_virtual_card get_physical_card getting_spare_card getting_virtual_card lost_or_stolen_card lost_or_stolen_phone order_physical_card passcode_forgotten pending_card_payment pending_cash_withdrawal pending_top_up pending_transfer pin_blocked receiving_money refund_not_showing_up request_refund reverted_card_payment supported_cards_and_currencies terminate_account top_up_by_bank_transfer_charge top_up_by_card_charge top_up_by_cash_or_cheque top_up_failed top_up_limits top_up_reverted topping_up_by_card transaction_charged_twice transfer_fee_charged transfer_into_account transfer_not_received_by_recipient transfer_timing unable_to_verify_identity verify_my_identity verify_source_of_funds verify_top_up virtual_card_not_working visa_or_mastercard why_verify_identity wrong_amount_of_cash_received wrong_exchange_rate_for_cash_withdrawal".split()
# Queue design (my mapping, disclosed on the page)
Q = {
 'Fraud and security': 'card_payment_not_recognised cash_withdrawal_not_recognised compromised_card direct_debit_payment_not_recognised lost_or_stolen_card lost_or_stolen_phone',
 'Disputes and refunds': 'request_refund refund_not_showing_up transaction_charged_twice reverted_card_payment extra_charge_on_statement wrong_amount_of_cash_received card_payment_wrong_exchange_rate wrong_exchange_rate_for_cash_withdrawal',
 'Cards': 'activate_my_card card_about_to_expire card_acceptance card_arrival card_delivery_estimate card_linking card_not_working card_swallowed change_pin contactless_not_working declined_card_payment get_physical_card getting_spare_card order_physical_card pin_blocked visa_or_mastercard virtual_card_not_working getting_virtual_card get_disposable_virtual_card disposable_card_limits apple_pay_or_google_pay',
 'Transfers and payments': 'beneficiary_not_allowed cancel_transfer declined_transfer failed_transfer pending_transfer receiving_money transfer_into_account transfer_not_received_by_recipient transfer_timing balance_not_updated_after_bank_transfer pending_card_payment',
 'Top-ups': 'automatic_top_up pending_top_up top_up_by_bank_transfer_charge top_up_by_card_charge top_up_by_cash_or_cheque top_up_failed top_up_limits top_up_reverted topping_up_by_card verify_top_up balance_not_updated_after_cheque_or_cash_deposit',
 'Cash and ATMs': 'atm_support declined_cash_withdrawal pending_cash_withdrawal cash_withdrawal_charge',
 'Fees and FX': 'card_payment_fee_charged exchange_charge exchange_rate exchange_via_app fiat_currency_support supported_cards_and_currencies transfer_fee_charged country_support',
 'Identity and account': 'age_limit edit_personal_details passcode_forgotten terminate_account unable_to_verify_identity verify_my_identity verify_source_of_funds why_verify_identity',
}
I2Q = {i: q for q, s in Q.items() for i in s.split()}
assert set(I2Q) == set(NAMES), set(NAMES) - set(I2Q)
URGENT = set('compromised_card lost_or_stolen_card lost_or_stolen_phone card_payment_not_recognised cash_withdrawal_not_recognised direct_debit_payment_not_recognised card_swallowed'.split())
QS = list(Q)
tr = pd.read_parquet(D + 'b77_train.parquet'); te = pd.read_parquet(D + 'b77_test.parquet')
for d in (tr, te):
    d['intent'] = d.label.map(lambda k: NAMES[k]); d['queue'] = d.intent.map(I2Q); d['urgent'] = d.intent.isin(URGENT)
# Keyword rules: what a team writes on day one
KW = [('Fraud and security', r"stolen|lost|not recogni|don'?t recogni|didn'?t make|fraud|hack|compromis|someone (used|else)|unauthori"),
      ('Disputes and refunds', r'refund|charged twice|twice|reverted|wrong amount|dispute|money back'),
      ('Top-ups', r'top.?up|topup|top me up'),
      ('Cash and ATMs', r'\batm\b|cash|withdraw'),
      ('Identity and account', r'identity|verif|passcode|close my account|personal details|age|delete my account'),
      ('Fees and FX', r'fee|charge|exchange|currenc|rate'),
      ('Transfers and payments', r'transfer|payment|send money|beneficiar|receive'),
      ('Cards', r'card|pin|contactless|apple pay|google pay')]
def rules(t):
    t = t.lower()
    for q, p in KW:
        if re.search(p, t): return q
    return 'Cards'
URG_KW = r"stolen|lost my|not recogni|don'?t recogni|didn'?t make|fraud|hack|compromis|swallow|someone (used|else)|unauthori"
vec = make_union(TfidfVectorizer(ngram_range=(1, 2), min_df=1, sublinear_tf=True), TfidfVectorizer(analyzer='char_wb', ngram_range=(3, 5), min_df=2, sublinear_tf=True))
Xtr = vec.fit_transform(tr.text); Xte = vec.transform(te.text)
clf = LogisticRegression(C=20, max_iter=3000); clf.fit(Xtr, tr.label)
P = clf.predict_proba(Xte); pi = P.argmax(1); conf = P.max(1)
# queue probability = sum of intent probabilities in the queue
qmat = np.zeros((77, len(QS)))
for k, nm in enumerate(NAMES): qmat[k, QS.index(I2Q[nm])] = 1
PQ = P @ qmat; pq = PQ.argmax(1); qconf = PQ.max(1)
y_q = te.queue.map(QS.index).values; y_u = te.urgent.values
urg_idx = [k for k, nm in enumerate(NAMES) if nm in URGENT]; pu = P[:, urg_idx].sum(1)
rb = np.array([QS.index(rules(t)) for t in te.text]); ru = te.text.str.lower().str.contains(URG_KW, regex=True).values
rng = np.random.default_rng(7)
def boot(f, n=1000):
    m = len(te); v = [f(rng.integers(0, m, m)) for _ in range(n)]; return [float(np.percentile(v, 2.5)), float(np.percentile(v, 97.5))]
R = {'n_train': len(tr), 'n_test': len(te), 'n_intents': 77, 'queues': QS}
R['intent_acc'] = float((pi == te.label.values).mean()); R['intent_acc_ci'] = boot(lambda i: (pi[i] == te.label.values[i]).mean())
R['queue_acc'] = float((pq == y_q).mean()); R['queue_acc_ci'] = boot(lambda i: (pq[i] == y_q[i]).mean())
R['rules_acc'] = float((rb == y_q).mean()); R['rules_acc_ci'] = boot(lambda i: (rb[i] == y_q[i]).mean())
maj = np.bincount(tr.queue.map(QS.index)).argmax(); R['major_acc'] = float((y_q == maj).mean()); R['major_q'] = QS[maj]
R['queue_f1_model'] = float(f1_score(y_q, pq, average='macro')); R['queue_f1_rules'] = float(f1_score(y_q, rb, average='macro'))
# per-queue accuracy (recall) both methods
R['per_queue'] = [[q, int((y_q == j).sum()), float((pq[y_q == j] == j).mean()), float((rb[y_q == j] == j).mean())] for j, q in enumerate(QS)]
# urgency: model flag at threshold chosen on train cross-val -> use 0.30 fixed and report sweep
def urg(th): f = pu >= th; tp = (f & y_u).sum(); return dict(th=th, recall=float(tp / y_u.sum()), precision=float(tp / max(1, f.sum())), flagged=int(f.sum()))
R['urgent_n'] = int(y_u.sum()); R['urgent_sweep'] = [urg(t) for t in (0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7)]
tp = (ru & y_u).sum(); R['urgent_rules'] = dict(recall=float(tp / y_u.sum()), precision=float(tp / max(1, ru.sum())), flagged=int(ru.sum()))
# coverage-accuracy for auto-routing by queue confidence
cov = []
for th in np.round(np.arange(0.30, 1.0, 0.05), 2):
    m = qconf >= th; cov.append([float(th), float(m.mean()), float((pq[m] == y_q[m]).mean()) if m.any() else None])
R['coverage'] = cov
th = 0.80; m = qconf >= th; R['bar'] = dict(th=th, auto=float(m.mean()), acc_auto=float((pq[m] == y_q[m]).mean()), held=int((~m).sum()), acc_held=float((pq[~m] == y_q[~m]).mean()))
# urgent never auto-closed: urgent among held/auto
R['bar']['urgent_auto_missed'] = int(((pq != y_q) & m & y_u).sum())
# confusions (queue level, model)
from collections import Counter
cf = Counter((QS[a], QS[b]) for a, b in zip(y_q, pq) if a != b); R['top_confusions'] = [[a, b, c] for (a, b), c in cf.most_common(6)]
# hardest intents
ia = te.assign(ok=(pi == te.label.values)).groupby('intent').ok.mean().sort_values(); R['hard_intents'] = [[k, float(v)] for k, v in ia.head(6).items()]
# example errors (queue-level)
ex = te.assign(pred=[QS[k] for k in pq], c=qconf)[pq != y_q].sort_values('c', ascending=False).head(6)
R['errors'] = ex[['text', 'queue', 'pred', 'c']].values.tolist()
R['len_words_median'] = float(te.text.str.split().str.len().median())
R['test_queue_counts'] = te.queue.value_counts().to_dict()
json.dump(R, open('/workspace/cs7/out/b77.json', 'w'), indent=1, default=float)
print(json.dumps({k: R[k] for k in ['intent_acc', 'queue_acc', 'queue_acc_ci', 'rules_acc', 'major_acc', 'queue_f1_model', 'queue_f1_rules', 'urgent_rules', 'bar']}, indent=1))
print(R['urgent_sweep']); print(R['per_queue']); print(R['top_confusions'])
