"""Recalcul indépendant du classement des agences immobilières de Nice (meilleures-agences-immo-cote-dazur.fr).

Usage : placer ce script dans un dossier avec les fichiers du dossier de reproduction
(https://meilleures-agences-immo-cote-dazur.fr/methode/reproduction/), puis : python3 recalcul.py
Aucune dépendance : bibliothèque standard de Python 3 seulement.

Le script recalcule les piliers et la note de chaque agence à partir des données élémentaires, avec les règles
publiées sur https://meilleures-agences-immo-cote-dazur.fr/methode/ , puis compare avec les notes publiées. Ce qu'il ne refait pas :
la collecte (avis, sites, registres), la lecture des textes par l'IA (profil de l'auteur, problème signalé) et la
détection des doublons ; leurs résultats sont fournis dans les colonnes des fichiers, et ces étapes sont décrites
dans la page méthode et dans lecture-des-avis.txt.
"""
import csv, json, math, datetime, statistics, sys, os

D = os.path.dirname(os.path.abspath(__file__))


def rows(name):
    with open(os.path.join(D, name), encoding='utf-8') as f:
        return list(csv.DictReader(f, delimiter=';'))


P = json.load(open(os.path.join(D, 'parametres.json'), encoding='utf-8'))
TODAY = datetime.date.fromisoformat(P['date_releve'])
W = P['poids']                 # poids des six piliers (somme des poids de leurs critères)
CW = P['poids_criteres']       # méthode v6 : poids de chacun des 19 critères dans la note (total 100)


def months_back(n):
    y, m, out = TODAY.year, TODAY.month, set()
    for _ in range(n):
        out.add(f'{y:04d}-{m:02d}'); m -= 1
        if m == 0: y, m = y - 1, 12
    return out


WIN = months_back(12)


def age_weight(d):
    try:
        m = (TODAY - datetime.date.fromisoformat(d[:10])).days / 30.44
    except (TypeError, ValueError):
        return P['poids_avis_sans_date']
    return 2 ** (-max(0.0, m) / P['demi_vie_mois'])


def group(rs, key='agence'):
    g = {}
    for r in rs: g.setdefault(r[key], []).append(r)
    return g


AGG, ITEMS, CRIT = group(rows('agregats-plateformes.csv')), group(rows('avis-elementaires.csv')), group(rows('criteres-sites.csv'))
AG = rows('agences.csv')
SRC = {r['agence']: r for r in rows('sources-agences.csv')}


def controles():
    """Contrôles d'intégrité (audit ChatGPT du 18/11/2026) : le script échoue si les données sont incohérentes."""
    err = []
    for k, v in CW.items():
        if abs(sum(v.values()) - W[k]) > 1e-9: err.append(f"poids du pilier {k} : {W[k]} au lieu de la somme de ses critères {sum(v.values())}")
    if abs(sum(sum(v.values()) for v in CW.values()) - 100) > 1e-9: err.append('la somme des poids des critères ne vaut pas 100')
    for a in AG:
        s = a['agence']; src = SRC.get(s)
        if not src: err.append(f'{s} : absente de sources-agences.csv'); continue
        st = src['statut_avis_google']
        if st not in ('releve', 'non_releve'): err.append(f'{s} : statut_avis_google inconnu « {st} »')
        g = [r for r in ITEMS.get(s, []) if r['plateforme'] == 'google']
        if st == 'releve' and not (g and all(r['releve_complet'] == '1' for r in g)):
            err.append(f'{s} : statut « releve » sans avis Google individuels issus d\'un relevé complet')
        if st == 'non_releve' and any(r['releve_complet'] == '1' for r in g):
            err.append(f'{s} : statut « non_releve » alors que des avis Google d\'un relevé complet sont publiés')
        h = [r for r in CRIT.get(s, []) if r['pilier'] == 'hono']
        if (src['bareme_illisible'] == '1') != (len(h) == 1 and h[0]['max'] == '100' and float(h[0]['points']) == 20):
            if src['bareme_illisible'] == '1' or (len(h) == 1 and h[0]['max'] == '100'):
                err.append(f'{s} : barème illisible incohérent (colonne {src["bareme_illisible"]}, {len(h)} ligne(s) honoraires)')
    return err

# Moyenne de Nice : moyenne des notes moyennes (toutes plateformes) des agences référencées
means = [sum(float(r['note']) * float(r['nombre']) for r in rs) / sum(float(r['nombre']) for r in rs) for rs in AGG.values()]
M_REF = round(statistics.mean(means), 3)


def pillar_avis(slug):
    it, agg = ITEMS.get(slug, []), AGG.get(slug, [])
    detailed = {r['plateforme'] for r in it if r['releve_complet'] == '1'}
    sw = sr = n = 0.0
    for r in it:
        if r['retenu_qualite'] != '1': continue
        k = 1 / int(r['nb_agences_partageant'])
        w = age_weight(r['date']) * k
        sw += w; sr += w * float(r['note']); n += k
    for r in agg:
        if r['plateforme'] in detailed: continue
        k = float(r['nombre']); sw += P['poids_avis_sans_date'] * k; sr += P['poids_avis_sans_date'] * float(r['note']) * k; n += k
    C = P['avis_fictifs_PRIOR']
    mean = (C * M_REF + sr) / (C + sw) if sw else None
    q = round(max(0.0, min(100.0, (mean - 3) / 2 * 100)), 1) if mean else 50.0
    v = round(min(100.0, 100 * math.log(1 + n) / math.log(P['plafond_volume'] + 1)), 1)
    kept = [r for r in it if r['compte_vente_achat'] == '1']
    rec = [r for r in kept if r['date'][:7] in WIN]
    if it:
        months = {r['date'][:7] for r in rec}
        reg = round(min(1.0, len(months) / min(12, max(3, len(rec)))) * 100, 1) if rec else 0.0
    else:
        reg = 0.0 if not agg else None
    wq, wv, wr = (CW['avis'][k] for k in ('qualite', 'volume', 'regularite'))
    total = (wq * q + wv * v + wr * reg) / (wq + wv + wr) if reg is not None else (wq * q + wv * v) / (wq + wv)
    return round(total, 1)


def pillar_serv(slug):
    it = [r for r in ITEMS.get(slug, []) if r['compte_vente_achat'] == '1']
    neg = [r for r in it if r['plateforme'] == 'google' and float(r['note'] or 5) <= 3 and r['reponse_agence'] != '']
    # v6 : avis négatifs Google -> (réponses + 2) / (négatifs + 4) ; aucun négatif dans un relevé Google complet -> critère
    # sans objet, retiré (son poids va aux problèmes de service) ; avis Google non relevés un par un -> neutre 50
    if neg: rep = round(100 * (sum(1 for r in neg if r['reponse_agence'] == '1') + 2) / (len(neg) + 4), 1)
    elif SRC[slug]['statut_avis_google'] == 'releve': rep = None
    else: rep = 50.0
    rd = [r for r in it if r['retenu_service'] == '1' and r['probleme'] in ('probleme', 'ok')]
    if len(rd) >= 10:
        p = sum(1 for r in rd if r['probleme'] == 'probleme') / len(rd)
        txt = round(max(0.0, 100 * (1 - p / 0.25)), 1)
    else:
        txt = 50.0
    wr, wt = CW['serv']['reponses'], CW['serv']['problemes']
    return txt if rep is None else round((rep * wr + txt * wt) / (wr + wt), 1)


def pct(slug, pillar):
    it = [r for r in CRIT.get(slug, []) if r['pilier'] == pillar and r['max'] not in ('', '0')]
    m = sum(float(r['max']) for r in it)
    return round(100 * sum(float(r['points'] or 0) for r in it) / m, 1) if m else None


def pillar_hono(slug):
    # points = poids du critère dans la note x 10 ; barème trouvé mais illisible : une ligne unique 20 sur 100
    return pct(slug, 'hono')


def pillar_anc(a):
    d = a['date_anciennete']
    if not d: return None
    y, mo = int(d[:4]), int(d[5:7]) if len(d) >= 7 else 6
    years = (TODAY.year - y) + (TODAY.month - mo) / 12
    return round(max(0.0, min(100.0, years / 20 * 100)), 1)


def main():
    print(f"Relevé du {TODAY} — moyenne de Nice recalculée : {M_REF} (publiée : {P['moyenne_nice_M_REF']})")
    err = controles()
    for e in err: print('INCOHÉRENCE', e)
    print(f"Contrôles d'intégrité : {'aucune incohérence' if not err else f'{len(err)} incohérence(s)'}")
    res, bad = [], 0
    for a in AG:
        s = a['agence']
        sc = {'avis': pillar_avis(s), 'serv': pillar_serv(s), 'hono': pillar_hono(s), 'conf': pct(s, 'conf'),
              'info': pct(s, 'info'), 'anc': pillar_anc(a)}
        if a['sans_site'] == '1':   # aucun site propre : honoraires, mentions légales et information valent 0 (règle publiée)
            sc['hono'] = sc['conf'] = sc['info'] = 0.0
        for k in sc:
            if sc[k] is None and W[k]: sc[k] = 50.0   # donnée non relevée : valeur neutre provisoire (piliers notés seulement)
        t = round(sum((sc[k] or 0) * W[k] for k in W) / sum(W.values()), 2)   # moyenne pondérée des piliers arrondis, au centième
        pub = {k: (float(a[c]) if a[c] != '' else None) for k, c in zip(('avis', 'serv', 'hono', 'conf', 'info', 'anc'),
                                               ('avis', 'service', 'honoraires', 'mentions_legales', 'information', 'anciennete'))}
        # comparaison exacte : piliers au dixième, note au centième
        diff = [k for k in sc if (sc[k] is None) != (pub[k] is None) or (sc[k] is not None and round(sc[k], 1) != round(pub[k], 1))]
        if diff or t != round(float(a['note_publiee']), 2):
            bad += 1
            print(f"ÉCART {s} : piliers {', '.join(f'{k} {sc[k]} / publié {pub[k]}' for k in diff) or '—'} ; note {t:.2f} / publiée {float(a['note_publiee']):.2f}")
        res.append((t, s, a['rang_publie'], int(a['nb_avis_total'] or 0)))
    res.sort(key=lambda x: (-x[0], -x[3]))   # égalité de note : départage par le nombre total d'avis (règle publiée)
    rang = {s: i for i, (_, s, _, _) in enumerate(res, 1)}
    bad_rank = [s for _, s, rk, _ in res if rang[s] != int(rk)]
    print(f"Rangs recalculés identiques au classement publié : {len(res) - len(bad_rank)} sur {len(res)}" + (f" (écarts : {', '.join(bad_rank[:10])})" if bad_rank else ''))
    print(f"{len(AG)} agences recalculées ; {len(AG) - bad} identiques au classement publié, {bad} avec écart.")
    print('Top 10 recalculé :')
    for i, (t, s, rk, _) in enumerate(res[:10], 1):
        print(f"  {i:>2}. {s} — {t:.2f} (rang publié {rk})")
    return bad + len(bad_rank) + len(err)


if __name__ == '__main__':
    sys.exit(1 if main() else 0)
