#!/usr/bin/env python3
"""Compare complete alignment columns by residue indices, not amino-acid letters.

Usage: python3 compare_alignments.py first.fasta second.fasta --out-prefix result
Requires aligned FASTA, unique first-token IDs, identical ID sets and identical
ungapped sequences for each ID. Row order may differ. Gaps '-' and '.' are
accepted; columns containing only gaps are rejected. Column numbering is 1-based.
Outputs JSON statistics and TSV files of every matching column, maximal blocks
(length >= 2), isolated matches and unmatched intervals in each alignment.
Uses only Python's standard library.
"""
import argparse
import csv
import json
from pathlib import Path

def read_fasta(path):
    result, name = {}, None
    for line in Path(path).read_text().splitlines():
        line = line.strip()
        if not line or line.startswith(';'): continue
        if line.startswith('>'):
            name = line[1:].split()[0]
            if not name or name in result: raise ValueError('Empty/duplicate sequence ID')
            result[name] = ''
        elif name is None: raise ValueError('Sequence before FASTA header')
        else: result[name] += ''.join(line.split()).upper().replace('.', '-')
    if not result or len({len(s) for s in result.values()}) != 1:
        raise ValueError('Empty input or unequal aligned sequence lengths')
    if any(not s.replace('-', '').isalpha() for s in result.values()):
        raise ValueError('Sequences must contain amino-acid letters and gaps')
    return result

def signatures(alignment, ids):
    positions = [0] * len(ids)
    result = []
    for column in zip(*(alignment[n] for n in ids)):
        signature = []
        for row, aa in enumerate(column):
            if aa == '-': signature.append(0)
            else:
                positions[row] += 1
                signature.append(positions[row])
        if not any(signature): raise ValueError('All-gap columns must be removed before comparing')
        result.append(tuple(signature))
    if len(set(result)) != len(result): raise ValueError('Non-unique column signatures')
    return result

def intervals(numbers):
    out = []
    for n in numbers:
        if out and n == out[-1][1]+1: out[-1][1] = n
        else: out.append([n, n])
    return out

def compare(a, b):
    if set(a) != set(b): raise ValueError('Sequence ID sets differ')
    ids = list(a)
    for name in ids:
        if a[name].replace('-', '') != b[name].replace('-', ''):
            raise ValueError('Ungapped sequences differ: ' + name)
    sa, sb = signatures(a, ids), signatures(b, ids)
    index = {sig: i for i, sig in enumerate(sb, 1)}
    pairs = [[i,index[sig]] for i,sig in enumerate(sa,1) if sig in index]
    runs = []
    for x,y in pairs:
        if runs and x == runs[-1][1]+1 and y == runs[-1][3]+1:
            runs[-1][1],runs[-1][3] = x,y
        else: runs.append([x,x,y,y])
    blocks = [r for r in runs if r[1]-r[0]+1 >= 2]
    isolated = [[r[0],r[2]] for r in runs if r[0] == r[1]]
    ax,by = {x for x,y in pairs},{y for x,y in pairs}
    m,la,lb = len(pairs),len(sa),len(sb)
    return dict(sequence_ids=ids, lengths=[la,lb], identical_columns=m,
                fractions=[m/la,m/lb],jaccard=m/(la+lb-m),
                blocks=blocks,isolated=isolated,matches=pairs,
                unmatched_a=intervals(i for i in range(1,la+1) if i not in ax),
                unmatched_b=intervals(i for i in range(1,lb+1) if i not in by))

def write_tsv(path, columns, rows):
    with Path(path).open('w') as out:
        w=csv.writer(out,delimiter='\t');w.writerow(columns);w.writerows(rows)

def main():
    p=argparse.ArgumentParser(description=__doc__,formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument('first');p.add_argument('second');p.add_argument('--out-prefix',required=True)
    args=p.parse_args()
    try: r=compare(read_fasta(args.first),read_fasta(args.second))
    except ValueError as e: p.error(str(e))
    r['inputs']=[Path(args.first).name,Path(args.second).name]
    prefix=args.out_prefix;Path(prefix).parent.mkdir(parents=True,exist_ok=True)
    Path(prefix+'.json').write_text(json.dumps(r,indent=2))
    write_tsv(prefix+'_columns.tsv',['column_1','column_2'],r['matches'])
    write_tsv(prefix+'_blocks.tsv',['start_1','end_1','start_2','end_2','length'],
              [x+[x[1]-x[0]+1] for x in r['blocks']])
    write_tsv(prefix+'_isolated.tsv',['column_1','column_2'],r['isolated'])
    for tag,key in [('1','unmatched_a'),('2','unmatched_b')]:
        write_tsv(prefix+'_unmatched_'+tag+'.tsv',['start','end'],r[key])
    print(json.dumps({k:v for k,v in r.items() if k not in ('matches',)},indent=2))

if __name__ == '__main__': main()
