#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
verificador_eiguis.py — CONFERE UM RELATORIO EMITIDO SEM CONTA, SEM REDE, SEM A PLATAFORMA
========================================================================================
Para o assistente tecnico da outra parte, para o perito, para o juiz.

  python3 verificador_eiguis.py verificacao_EIG-0041-XXXX.json
  python3 verificador_eiguis.py verificacao_EIG-0041-XXXX.json --originais pasta_com_os_arquivos/
  python3 verificador_eiguis.py verificacao.json --originais pasta/ --publico publico_EIG-0041-XXXX.json

Dependencias: NENHUMA alem da biblioteca padrao do Python 3.8+.
Rede: NENHUMA. O script nao abre conexao alguma.

O que confere, nesta ordem (cada item imprime OK ou FALHA, e o motivo):
  1. ARQUIVO      o JSON e um arquivo de verificacao da Eiguis, versao conhecida.
  2. RECIBOS      para cada achado: sha256 do recibo recalculado bate com o gravado
                  (camada de integridade: o recibo nao foi alterado).
  3. CAMPOS       cada recibo tem: sha256 do original, local (pagina+deslocamento/recorte,
                  ou linha+coluna/campo), motor id+versao, regra id+versao, carimbo UTC.
                  Faltou um -> REJEITADO.
  4. ARVORE       a arvore Merkle dos recibos da a raiz do lote; e a prova de inclusao
                  de cada recibo fecha na raiz.
  5. ANCORA       a prova OpenTimestamps (.ots) parte da raiz do lote e chega a uma
                  atestacao Bitcoin (altura do bloco + raiz de merkle do bloco) ou esta
                  pendente. A leitura do bloco na rede e o UNICO passo que este script nao
                  faz: ele imprime altura e raiz para conferencia em qualquer explorador ou no.
  6. ORIGINAIS    (com --originais) sha256 de cada arquivo original bate com o recibo.
  7. TRECHOS      (arquivo com trechos) o hash do trecho (sha256 e sha3-256) bate com o gravado E esta num local do
                  recibo (o texto do trecho fica fora do hash do recibo: o que o prende ao recibo e esse hash);
                  se o local e linha/coluna de um CSV e o original esta na pasta, le a celula e compara;
                  se e pagina de PDF e ha `pdftotext` na maquina, extrai a pagina e procura o trecho.
                  PAGINA EM IMAGEM (processo digitalizado): o trecho veio do reconhecimento de caracteres da
                  imagem; este programa nao le imagem. Ele mede a pagina (pdfimages, pdfinfo) e, se ela e imagem,
                  NAO rejeita e NAO da por conferido: lista arquivo, pagina e trecho para conferencia a olho.
  8. PUBLICO      (com --publico) a raiz e o .ots do arquivo publico da plataforma sao os
                  mesmos deste arquivo.
  9. SELO         se o arquivo traz o selo do relatorio: 'lote:<raiz>' esta entre os itens
                  do selo e a arvore dos itens da a raiz do selo (o relatorio amarra o lote).
Saida final: ACEITO, ACEITO COM RESSALVA (nada falhou, mas ha o que este programa nao cobriu: vem listado) ou
REJEITADO, com a lista do que falhou. Codigo de saida 0 (aceito, com ou sem ressalva) / 1 (rejeitado).
Arquivo fora da forma esperada nunca derruba o programa: e tratado como alterado e REJEITADO.

Formato do .ots (compativel com python-opentimestamps): ver funcao ots_conferir.
Merkle: folha = sha256(0x00 || item), no = sha256(0x01 || esq || dir), no impar sobe intacto.
Este arquivo e publico e pode ser lido linha a linha. Nao contem chave nem segredo.
"""
import sys, os, json, hashlib, base64, csv, struct, argparse, subprocess, shutil, unicodedata, re

FALHAS, OKS, AVISOS = [], [], []
VERSAO = 'verificador_eiguis 1.1'   # PV83
A_OLHO = []        # PV83: (achado, arquivo, onde, trecho, motivo) — o que este programa nao consegue ler e fica para conferencia a olho
NAO_COBRE = []     # PV83: o que nada falhou mas este resultado nao cobre (registro publico nao comparado, ancora pendente...)
IMAGEM_MIN = 0.5   # PV83: pagina em que as imagens cobrem pelo menos metade da area e tratada como pagina digitalizada (a medida vai impressa)



def _vis(s):
    """PV83: o que vem do arquivo de verificacao e vai para a tela sai sem caractere de controle (nada de comando de terminal escondido num trecho)"""
    return re.sub(r'\s+', ' ', ''.join(ch if ch.isprintable() or ch in '\n\t ' else '?' for ch in str(s))).strip()


def ok(m):
    OKS.append(m); print('  OK     ' + m)


def falha(m):
    FALHAS.append(m); print('  FALHA  ' + m)


def aviso(m):
    AVISOS.append(m); print('  aviso  ' + m)


# ─────────────────────────── canonico / merkle ───────────────────────────
def canon(obj):
    return json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':'), default=str)


def sha_canon(obj):
    return hashlib.sha256(canon(obj).encode('utf-8')).hexdigest()


def h(b):
    return hashlib.sha256(b).digest()


def hash_bate(gravado, dados):
    """aceita '<64 hex>' (sha256) ou 'sha256:<hex>|sha3:<hex>' (hash duplo da asercao)"""
    g = str(gravado or '')
    if re.fullmatch(r'[0-9a-f]{64}', g):
        return hashlib.sha256(dados).hexdigest() == g
    m = re.fullmatch(r'sha256:([0-9a-f]{64})\|sha3:([0-9a-f]{64})', g)
    if m:
        return hashlib.sha256(dados).hexdigest() == m.group(1) and hashlib.sha3_256(dados).hexdigest() == m.group(2)
    return False


def hash_valido(g):
    return bool(re.fullmatch(r'[0-9a-f]{64}', str(g or '')) or re.fullmatch(r'sha256:[0-9a-f]{64}\|sha3:[0-9a-f]{64}', str(g or '')))


def merkle(itens):
    if not itens:
        return None, []
    nivel = [h(b'\x00' + x.encode('utf-8')) for x in itens]
    niveis = [list(nivel)]
    while len(nivel) > 1:
        acima = []
        for i in range(0, len(nivel), 2):
            acima.append(h(b'\x01' + nivel[i] + nivel[i + 1]) if i + 1 < len(nivel) else nivel[i])
        nivel = acima; niveis.append(list(nivel))
    return nivel[0].hex(), niveis


def prova_fecha(item, prova, raiz):
    atual = h(b'\x00' + item.encode('utf-8'))
    for p in prova:
        irmao = bytes.fromhex(p['hash'])
        atual = h(b'\x01' + irmao + atual) if p.get('lado') == 'esq' else h(b'\x01' + atual + irmao)
    return atual.hex() == (raiz or '').lower()


# ─────────────────────────── opentimestamps (leitura) ───────────────────────────
MAGIC = b'\x00OpenTimestamps\x00\x00Proof\x00\xbf\x89\xe2\xe8\x84\xe8\x92\x94'
TAG_BITCOIN = bytes.fromhex('0588960d73d71901')
TAG_PENDENTE = bytes.fromhex('83dfe30d2ef90c8e')


def ripemd160(msg):
    try:
        return hashlib.new('ripemd160', msg).digest()
    except Exception:
        pass
    def rol(x, n): return ((x << n) | (x >> (32 - n))) & 0xffffffff
    r = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]
    rr = [5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]
    s = [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6]
    ss = [8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11]
    K = [0, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]; KK = [0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0]
    def f(j, x, y, z):
        if j < 16: return x ^ y ^ z
        if j < 32: return (x & y) | (~x & z)
        if j < 48: return (x | ~y) ^ z
        if j < 64: return (x & z) | (y & ~z)
        return x ^ (y | ~z)
    H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]
    ml = len(msg) * 8
    msg += b'\x80' + b'\x00' * ((55 - len(msg)) % 64) + struct.pack('<Q', ml)
    for off in range(0, len(msg), 64):
        X = struct.unpack('<16L', msg[off:off + 64]); al, bl, cl, dl, el = H; ar, br, cr, dr, er = H
        for j in range(80):
            t = (rol((al + f(j, bl, cl, dl) + X[r[j]] + K[j // 16]) & 0xffffffff, s[j]) + el) & 0xffffffff
            al, el, dl, cl, bl = el, dl, rol(cl, 10), bl, t
            t = (rol((ar + f(79 - j, br, cr, dr) + X[rr[j]] + KK[j // 16]) & 0xffffffff, ss[j]) + er) & 0xffffffff
            ar, er, dr, cr, br = er, dr, rol(cr, 10), br, t
        t = (H[1] + cl + dr) & 0xffffffff
        H = [t, (H[2] + dl + er) & 0xffffffff, (H[3] + el + ar) & 0xffffffff, (H[4] + al + br) & 0xffffffff, (H[0] + bl + cr) & 0xffffffff]
    return struct.pack('<5L', *H)


class Leitor:
    def __init__(self, b): self.b, self.i = b, 0
    def byte(self):
        if self.i >= len(self.b): raise ValueError('fim inesperado do .ots')
        v = self.b[self.i]; self.i += 1; return v
    def bytes(self, n):
        if self.i + n > len(self.b): raise ValueError('fim inesperado do .ots')
        v = self.b[self.i:self.i + n]; self.i += n; return v
    def varint(self):
        v, s = 0, 0
        while True:
            c = self.byte(); v |= (c & 0x7f) << s
            if not c & 0x80: return v
            s += 7
    def varbytes(self):
        n = self.varint()
        if n > 4096: raise ValueError('varbytes acima do limite')
        return self.bytes(n)


def ots_op(tag, arg, msg):
    if tag == 0x08: return hashlib.sha256(msg).digest()
    if tag == 0x03: return ripemd160(msg)
    if tag == 0x02: return hashlib.sha1(msg).digest()
    if tag == 0xf0: return msg + arg
    if tag == 0xf1: return arg + msg
    if tag == 0xf2: return msg[::-1]
    if tag == 0xf3: return msg.hex().encode('ascii')
    raise ValueError('operacao desconhecida 0x%02x' % tag)


def ots_ler(L, msg, saida, passos=0):
    def um(tag):
        if tag == 0x00:
            t = L.bytes(8); p = L.varbytes(); P = Leitor(p)
            if t == TAG_BITCOIN:
                saida.append({'tipo': 'bitcoin', 'altura': P.varint(), 'merkle_interno': msg.hex(), 'merkle_explorador': msg[::-1].hex(), 'passos': passos})
            elif t == TAG_PENDENTE:
                saida.append({'tipo': 'pendente', 'uri': P.varbytes().decode('utf-8', 'replace'), 'compromisso': msg.hex()})
            else:
                saida.append({'tipo': 'desconhecida', 'tag': t.hex()})
        else:
            arg = L.varbytes() if tag in (0xf0, 0xf1) else b''
            ots_ler(L, ots_op(tag, arg, msg), saida, passos + 1)
    tag = L.byte()
    while tag == 0xff:
        um(L.byte()); tag = L.byte()
    um(tag)


def ots_conferir(ots, digest_hex):
    if not ots.startswith(MAGIC):
        return None, 'cabecalho .ots invalido'
    L = Leitor(ots[len(MAGIC):])
    if L.varint() != 1: return None, 'versao .ots desconhecida'
    if L.byte() != 0x08: return None, 'hash de arquivo nao e sha256'
    d = L.bytes(32)
    if d.hex() != digest_hex.lower():
        return None, 'o .ots foi feito para outro digest (%s...)' % d.hex()[:16]
    at = []; ots_ler(L, d, at)
    return at, ''


# ─────────────────────────── conferencias ───────────────────────────
OBRIGATORIOS = [('original', 'sha256 do original'), ('local', 'local do achado'), ('motor', 'motor'), ('regra', 'regra'), ('extraido_em', 'carimbo de extracao')]


def campos_ok(c):
    faltas = []
    for k, nome in OBRIGATORIOS:
        if not c.get(k):
            faltas.append(nome)
    for o in c.get('original') or []:
        if not re.fullmatch(r'[0-9a-f]{64}', str(o.get('sha256') or '')):
            faltas.append('original %s sem sha256' % o.get('doc_id'))
    for l in c.get('local') or []:
        f = l.get('forma')
        if f in ('pdf_pagina', 'pdf_recorte'):
            if not l.get('pagina') or (l.get('offset') is None and not l.get('recorte')):
                faltas.append('local pdf sem pagina/deslocamento/recorte')
        elif f == 'tabela_linha':
            if l.get('linha') is None or (l.get('coluna') is None and not l.get('campo')):
                faltas.append('local de tabela sem linha+coluna/campo')
        elif f in ('texto_campo', 'texto_pos'):
            if l.get('offset') is None and l.get('pos') is None:
                faltas.append('local de texto sem deslocamento')
        else:
            faltas.append('forma de local desconhecida: %s' % f)
        if not hash_valido(l.get('trecho_hash')):
            faltas.append('trecho sem hash')
    m = c.get('motor') or {}
    if not m.get('id') or not m.get('versao') or m.get('versao') == '?':
        faltas.append('motor sem id/versao')
    if 'estavel_entre_maquinas' not in m:
        faltas.append('motor sem declaracao de estabilidade')
    r = c.get('regra') or {}
    if not r.get('id') or r.get('id') == '?' or not r.get('versao'):
        faltas.append('regra sem id/versao')
    return faltas


def norm_txt(s):
    s = unicodedata.normalize('NFKD', s or '')
    s = ''.join(ch for ch in s if not unicodedata.combining(ch))
    return re.sub(r'\s+', ' ', s).strip().upper()


def paginas_do_pdf(caminho):
    """PV83: quantas paginas o PDF tem (pdfinfo); None se nao deu para saber"""
    if not shutil.which('pdfinfo'): return None
    try:
        r = subprocess.run(['pdfinfo', caminho], capture_output=True, text=True, timeout=120)
        m = re.search(r'^Pages:\s+(\d+)', r.stdout or '', re.M)
        return int(m.group(1)) if m else None
    except Exception:
        return None


def imagem_na_pagina(caminho, pg):
    """PV83: que fracao da pagina e coberta por imagem (0 a 1), medida com pdfimages -list e pdfinfo. (None, motivo) se nao deu para medir.
    Processo digitalizado e uma imagem do tamanho da pagina (as vezes em faixas), com o carimbo do tribunal em texto por cima."""
    if not shutil.which('pdfimages') or not shutil.which('pdfinfo'):
        return None, 'pdfimages/pdfinfo ausentes'
    try:
        ri = subprocess.run(['pdfinfo', '-f', str(pg), '-l', str(pg), caminho], capture_output=True, text=True, timeout=120)
        m = re.search(r'^Page\s+%s\s+size:\s+([\d.]+)\s+x\s+([\d.]+)\s+pts' % re.escape(str(pg)), ri.stdout or '', re.M)
        if not m: return None, 'pdfinfo nao deu o tamanho da pagina'
        area_pag = (float(m.group(1)) / 72.0) * (float(m.group(2)) / 72.0)
        if area_pag <= 0: return None, 'pagina sem area'
        rl = subprocess.run(['pdfimages', '-f', str(pg), '-l', str(pg), '-list', caminho], capture_output=True, text=True, timeout=120)
        if rl.returncode != 0: return None, 'pdfimages nao leu a pagina'
        area_img = 0.0; sem_medida = 0
        for ln in (rl.stdout or '').splitlines():
            c = ln.split()
            if len(c) < 14 or not c[0].isdigit() or c[2] not in ('image', 'stencil'): continue     # cabecalho, traco, mascara
            try:
                w, hgt, xp, yp = float(c[3]), float(c[4]), float(c[12]), float(c[13])
            except ValueError:
                sem_medida += 1; continue
            if xp <= 0 or yp <= 0: sem_medida += 1; continue
            area_img += (w / xp) * (hgt / yp)
        if not area_img and sem_medida: return None, '%d imagem(ns) sem resolucao declarada' % sem_medida
        return min(1.0, area_img / area_pag), ''
    except Exception as e:
        return None, 'medida falhou: %s' % type(e).__name__


def conferir_trecho_no_original(loc, trecho, caminho):
    """metodo de LEITURA (declarado): CSV por linha/coluna e exato; PDF por pagina depende de pdftotext"""
    if loc.get('forma') == 'tabela_linha' and caminho.lower().endswith(('.csv', '.txt', '.tsv')):
        try:
            with open(caminho, encoding='utf-8-sig', errors='replace', newline='') as f:
                amostra = f.read(4096); f.seek(0)
                try:
                    dial = csv.Sniffer().sniff(amostra, delimiters=';,\t|')
                except Exception:
                    dial = csv.excel; dial.delimiter = ';' if amostra.count(';') > amostra.count(',') else ','
                linhas = list(csv.reader(f, dial))
            ln = int(loc['linha'])
            for base in (0, 1, 2):     # linha pode ser 0-based, 1-based ou contar o cabecalho
                if 0 <= ln - base < len(linhas):
                    row = linhas[ln - base]
                    cel = None
                    col = loc.get('coluna')
                    if isinstance(col, int) and col < len(row):
                        cel = row[col]
                    elif col is not None and linhas and str(col) in linhas[0]:
                        cel = row[linhas[0].index(str(col))] if linhas[0].index(str(col)) < len(row) else None
                    if cel is not None and norm_txt(cel) == norm_txt(trecho):
                        return True, 'celula linha %d coluna %s confere (exato)' % (ln, col)
            return False, 'celula nao confere / nao localizada (linha %s coluna %s)' % (loc.get('linha'), loc.get('coluna'))
        except Exception as e:
            return None, 'nao consegui ler o CSV: %s' % type(e).__name__
    if loc.get('forma') in ('pdf_pagina', 'pdf_recorte') and caminho.lower().endswith('.pdf'):
        if not shutil.which('pdftotext'):
            return None, 'pdftotext ausente: conferencia da pagina e manual (abra a pagina %s)' % loc.get('pagina')
        try:
            pg = str(int(loc['pagina']))
            r = subprocess.run(['pdftotext', '-f', pg, '-l', pg, '-layout', caminho, '-'], capture_output=True, text=True, timeout=120)
            texto = norm_txt(r.stdout)
            t = norm_txt(trecho)
            if t and t[:60] in texto:
                return True, 'trecho localizado na pagina %s (leitura por pdftotext)' % pg
            # tolerancia: 40 primeiros caracteres
            if t and t[:40] in texto:
                return True, 'inicio do trecho localizado na pagina %s (leitura por pdftotext; extrator diferente do da ferramenta)' % pg
            # PV83: nao achou. Antes de dizer que falhou, saber se este metodo PODIA achar: pdftotext so le a camada de texto.
            if r.returncode != 0:
                n_pag = paginas_do_pdf(caminho)
                if n_pag is not None and int(pg) > n_pag:
                    return False, 'a pagina %s nao existe no arquivo (%d pagina(s))' % (pg, n_pag)
                return None, 'pdftotext nao leu a pagina %s (codigo %d): confira a olho' % (pg, r.returncode)
            letras = sum(1 for ch in texto if ch.isalnum())
            if not letras:
                return None, 'a pagina %s nao tem camada de texto (e imagem): este programa nao le imagem — confira a olho' % pg
            cob, det = imagem_na_pagina(caminho, pg)
            if cob is None:
                return None, 'o trecho nao esta na camada de texto da pagina %s e nao consegui medir se a pagina e imagem (%s) — confira a olho' % (pg, det)
            if cob >= IMAGEM_MIN:
                return None, ('a pagina %s e imagem (cobre %d%% da pagina) com %d caractere(s) de texto por cima (carimbo, numeracao): '
                              'o trecho veio da leitura da imagem, que este programa nao faz — confira a olho' % (pg, round(cob * 100), letras))
            return False, 'trecho NAO localizado na pagina %s pelo pdftotext; a pagina e de texto (imagem cobre %d%% dela): o trecho deveria estar na camada de texto' % (pg, round(cob * 100))
        except Exception as e:
            return None, 'pdftotext falhou: %s' % type(e).__name__
    return None, 'forma %s: conferencia manual no original' % loc.get('forma')


def main():
    ap = argparse.ArgumentParser(description='confere um relatorio emitido pela Eiguis sem conta e sem rede (%s)' % VERSAO)
    ap.add_argument('arquivo'); ap.add_argument('--originais', help='pasta com os arquivos originais (nome do documento ou <sha256>.<ext>)')
    ap.add_argument('--publico', help='JSON da rota publica /verificar/<codigo>, para comparar raiz e ancora')
    a = ap.parse_args()
    try:
        V = json.load(open(a.arquivo, encoding='utf-8'))
    except Exception as e:
        print('nao consegui ler o arquivo: %s' % e); return 1
    print('%s — %s\n' % (VERSAO, os.path.basename(a.arquivo)))
    # 1. arquivo
    if V.get('arquivo_versao') == '1' and 'lote' in V and 'recibos' in V:
        ok('arquivo de verificacao versao 1, lote %s, %d recibo(s), %d recusado(s)' % (V['lote'].get('id'), len(V['recibos']), len(V.get('recusados') or [])))
    else:
        falha('nao e um arquivo de verificacao conhecido'); return fim()
    lote = V['lote']
    # 2/3. recibos
    itens = []
    for r in V['recibos']:
        c = dict(r['recibo']); lote_do_recibo = c.pop('lote', None); c.pop('_trechos', None)
        sha = sha_canon(c)
        rot = 'achado %s (%s %s)' % (c.get('achado', {}).get('id'), c.get('regra', {}).get('id'), c.get('motor', {}).get('id'))
        if sha != r['sha256']:
            falha('%s: sha256 do recibo NAO bate (recalculado %s..., gravado %s...)' % (rot, sha[:12], r['sha256'][:12]))
        else:
            ok('%s: recibo integro (%s...)' % (rot, sha[:12]))
        f = campos_ok(c)
        if f:
            falha('%s: campos obrigatorios ausentes: %s' % (rot, ', '.join(f)))
        if lote_do_recibo and lote_do_recibo.get('raiz') != lote.get('raiz'):
            falha('%s: recibo aponta para outro lote' % rot)
        if lote_do_recibo and not prova_fecha(r['sha256'], lote_do_recibo.get('prova', []), lote.get('raiz')):
            falha('%s: prova de inclusao NAO fecha na raiz do lote' % rot)
        itens.append((r.get('posicao', len(itens)), r['sha256']))
    itens = [s for _, s in sorted(itens)]
    if V.get('recusados'):
        aviso('%d achado(s) recusado(s) no selo por falta de campo (nao entram no lote): %s' % (len(V['recusados']), '; '.join('%s: %s' % (x.get('asercao_id'), ', '.join(x.get('faltas') or [])) for x in V['recusados'][:5])))
    # 4. arvore
    raiz, _ = merkle(itens)
    if lote.get('itens') and lote['itens'] != itens:
        falha('a lista de itens do lote nao corresponde aos recibos presentes')
    if raiz == lote.get('raiz'):
        ok('arvore Merkle dos %d recibo(s) da a raiz do lote %s...' % (len(itens), (raiz or '')[:16]))
    else:
        falha('raiz recalculada %s... difere da raiz do lote %s...' % ((raiz or '-')[:16], (lote.get('raiz') or '-')[:16]))
    # 5. ancora
    anc = lote.get('ancora') or {}
    if anc.get('ots_base64'):
        try:
            ots = base64.b64decode(anc['ots_base64'])
            at, erro = ots_conferir(ots, lote['raiz'])
            if at is None:
                falha('ancora OpenTimestamps: %s' % erro)
            else:
                btc = [x for x in at if x['tipo'] == 'bitcoin']
                if btc:
                    ok('ancora OpenTimestamps: parte da raiz do lote e chega a atestacao BITCOIN bloco %d (%d passos)' % (btc[0]['altura'], btc[0]['passos']))
                    print('         para fechar a conferencia fora deste script: o bloco %d deve ter merkle root %s (como exploradores mostram)' % (btc[0]['altura'], btc[0]['merkle_explorador']))
                    if anc.get('bitcoin_altura') and anc['bitcoin_altura'] != btc[0]['altura']:
                        falha('altura do bloco no arquivo (%s) difere da prova (%s)' % (anc['bitcoin_altura'], btc[0]['altura']))
                else:
                    pend = [x for x in at if x['tipo'] == 'pendente']
                    aviso('ancora OpenTimestamps ainda PENDENTE em %d calendario(s) (%s): a prova parte da raiz certa, mas a atestacao Bitcoin ainda nao foi juntada — peca o arquivo atualizado' % (len(pend), ', '.join(sorted(set(x['uri'] for x in pend)))))
                    NAO_COBRE.append('DATA: a ancora externa ainda esta pendente; ate a atestacao ser juntada, a data do lote e a do servidor da plataforma')   # PV83
        except Exception as e:
            falha('ancora OpenTimestamps ilegivel: %s' % type(e).__name__)
    else:
        falha('lote SEM ancora externa (.ots ausente): a data do lote depende so do servidor da plataforma')
    # 6. originais
    if a.originais:
        vistos = set()
        for r in V['recibos']:
            for o in r['recibo'].get('original') or []:
                chave = (o.get('doc_id'), o.get('sha256'))
                if chave in vistos: continue
                vistos.add(chave)
                # PV83: so o nome do arquivo. Antes, um nome com caminho ('../x' ou '/x') fazia o programa abrir arquivo fora da pasta dada.
                cands = [os.path.join(a.originais, os.path.basename(str(o.get('nome') or '').replace('\\', '/')))] + [os.path.join(a.originais, f) for f in os.listdir(a.originais) if f.startswith(str(o.get('sha256'))[:16])]
                cam = next((c for c in cands if os.path.isfile(c)), None)
                if not cam:
                    falha('original doc %s (%s) nao esta na pasta' % (o.get('doc_id'), o.get('nome'))); continue
                hh = hashlib.sha256()
                with open(cam, 'rb') as f:
                    for bloco in iter(lambda: f.read(1 << 20), b''):
                        hh.update(bloco)
                if hh.hexdigest() == o.get('sha256'):
                    ok('original doc %s: sha256 do arquivo bate (%s)' % (o.get('doc_id'), os.path.basename(cam)))
                else:
                    falha('original doc %s: sha256 do arquivo NAO bate (%s)' % (o.get('doc_id'), os.path.basename(cam)))
    # 7. trechos
    n_tr = 0; n_tr_ok = 0
    for r in V['recibos']:
        rid = r['recibo'].get('achado', {}).get('id')
        for t in r['recibo'].get('_trechos') or []:
            if t.get('trecho') is None: continue
            n_tr += 1
            if not hash_bate(t.get('trecho_hash'), str(t['trecho']).encode('utf-8')):
                falha('achado %s: hash do trecho NAO bate com o gravado' % rid); continue
            # PV83: o texto do trecho fica FORA do hash do recibo. O que o prende ao recibo e o hash do trecho gravado num local, DENTRO do
            # recibo. Trecho cujo hash nao esta em nenhum local nao e deste recibo: antes era pulado em silencio e o arquivo saia ACEITO.
            loc = next((l for l in r['recibo'].get('local') or [] if l.get('trecho_hash') == t.get('trecho_hash')), None)
            if loc is None:
                falha('achado %s: trecho que NAO pertence ao recibo (o hash dele nao esta em nenhum local do recibo): texto posto ou trocado depois da emissao' % rid); continue
            if t.get('doc_id') is not None and loc.get('doc_id') is not None and t.get('doc_id') != loc.get('doc_id'):
                falha('achado %s: o trecho diz ser do documento %s e o recibo diz documento %s' % (rid, t.get('doc_id'), loc.get('doc_id'))); continue
            n_tr_ok += 1
            if not a.originais: continue
            o = next((x for x in r['recibo'].get('original') or [] if x.get('doc_id') == loc.get('doc_id')), None)
            onde = ('pagina %s' % loc.get('pagina')) if loc.get('pagina') else (('linha %s' % loc.get('linha')) if loc.get('linha') is not None else str(loc.get('forma')))
            if not o:
                aviso('achado %s: o recibo nao declara o original do documento %s: leitura nao conferida' % (rid, loc.get('doc_id')))
                A_OLHO.append((rid, 'documento %s' % loc.get('doc_id'), onde, str(t['trecho']), 'original nao declarado no recibo')); continue
            cam = os.path.join(a.originais, os.path.basename(str(o.get('nome') or '').replace('\\', '/')))   # so o nome: nunca um caminho para fora da pasta
            if not os.path.isfile(cam): continue          # ja apontado no passo 6 (original nao esta na pasta)
            res, msg = conferir_trecho_no_original(loc, t['trecho'], cam)
            (ok if res else (aviso if res is None else falha))('achado %s: %s' % (rid, msg))
            if res is None: A_OLHO.append((rid, os.path.basename(cam), onde, str(t['trecho']), msg))
    if n_tr:
        ok('%d trecho(s) com hash conferido e preso ao recibo' % n_tr_ok) if n_tr_ok else None
        if not a.originais:
            NAO_COBRE.append('LEITURA: os %d trecho(s) nao foram procurados nos arquivos originais (rode com --originais pasta/)' % n_tr_ok)
    else:
        aviso('arquivo sem trechos (versao publica): a conferencia do texto exige o arquivo entregue pelo autor do relatorio')
        NAO_COBRE.append('LEITURA: arquivo sem os trechos (versao publica): o texto de cada achado nao foi conferido')
    # 8. publico
    if a.publico:
        try:
            P = json.load(open(a.publico, encoding='utf-8'))
            pl = P.get('lote') or {}
            if pl.get('raiz') == lote.get('raiz'):
                ok('arquivo publico da plataforma tem a mesma raiz de lote')
            else:
                falha('arquivo publico tem raiz diferente (%s... x %s...)' % ((pl.get('raiz') or '-')[:12], (lote.get('raiz') or '-')[:12]))
            if (pl.get('ancora') or {}).get('bitcoin_altura') and anc.get('bitcoin_altura') and pl['ancora']['bitcoin_altura'] != anc['bitcoin_altura']:
                falha('altura do bloco difere entre o arquivo publico e este')
        except Exception as e:
            falha('nao consegui ler o arquivo publico: %s' % type(e).__name__)
    else:
        # PV83: sem o registro publico, tudo o que foi conferido acima e a coerencia do arquivo consigo mesmo
        NAO_COBRE.append('REGISTRO PUBLICO: nao comparado. Este resultado diz que o arquivo e coerente por dentro; para saber que e o que a plataforma '
                         'emitiu, baixe o JSON publico do codigo do relatorio e rode de novo com --publico')
    # 9. selo do relatorio
    selo = V.get('selo_relatorio')
    if selo:
        its = selo.get('itens') or []
        if ('lote:%s' % lote.get('raiz')) in its:
            ok('o selo do relatorio %s inclui o item lote:%s...' % (selo.get('codigo'), (lote.get('raiz') or '')[:12]))
        else:
            falha('o selo do relatorio %s NAO inclui este lote' % selo.get('codigo'))
        rz, _ = merkle(its)
        if rz == selo.get('raiz'):
            ok('arvore dos %d itens do selo da a raiz do selo (%s)' % (len(its), selo.get('codigo')))
        else:
            falha('raiz do selo nao confere com os itens listados')
    else:
        aviso('arquivo sem selo de relatorio: o lote existe, mas nao esta amarrado a um relatorio emitido')
    return fim()


def fim():
    print('\n' + '─' * 64)
    for av in AVISOS:
        pass
    if FALHAS:
        print('REJEITADO — %d falha(s):' % len(FALHAS))
        for f in FALHAS:
            print('  · ' + f)
        return 1
    if not A_OLHO and not NAO_COBRE:
        print('ACEITO — %d conferencia(s) ok, %d aviso(s).' % (len(OKS), len(AVISOS)))
        return 0
    # PV83: nada falhou, mas o resultado diz com todas as letras o que NAO cobriu
    print('ACEITO COM RESSALVA — %d conferencia(s) ok, %d aviso(s). Nada falhou; o que este resultado NAO cobre:' % (len(OKS), len(AVISOS)))
    if A_OLHO:
        print('  · LEITURA A CONFERIR A OLHO: %d trecho(s) que este programa nao consegue ler. Abra o arquivo na pagina e compare:' % len(A_OLHO))
        for rid, arq, onde, trecho, motivo in A_OLHO:
            print('      achado %s · %s · %s' % (_vis(rid), _vis(arq), _vis(onde)))
            print('        trecho: «%s»' % _vis(trecho)[:400])
    for n in NAO_COBRE:
        print('  · ' + n)
    return 0


def principal():
    """PV83: arquivo fora da forma esperada nao derruba o programa: e tratado como alterado"""
    try:
        return main()
    except SystemExit:
        raise
    except Exception as e:
        falha('o arquivo de verificacao nao tem a forma esperada (%s): tratado como alterado' % type(e).__name__)
        return fim()


if __name__ == '__main__':
    sys.exit(principal())
