"""Reproduce the 2019 Pandora fit against the local CORA checkout.

Run with CORA's Python environment. All input files and databases are read-only.
"""
import argparse
import csv
import hashlib
import json
import os
from contextlib import closing
from pathlib import Path
import sqlite3
import sys
from types import SimpleNamespace


def event_data(root):
    date, object_name, star = '2019-12-07', '(55) Pandora', 'HIP 24832'
    with closing(sqlite3.connect(
        (root / 'dbase/observations/occult/occult.sdb').as_uri() + '?mode=ro', uri=True,
    )) as db:
        db.row_factory = sqlite3.Row
        rows = db.execute(
            """SELECT id, date, detected, ut1, ut2, ut3, ut4, ut2err, ut3err,
                      method, timesrc, sitelon, sitelat, admnote
               FROM observations WHERE date=? AND sso=? AND star=?
               AND coalesce(status,'')!='Pending' ORDER BY detected, sitelat, id""",
            (date, object_name, star),
        )
        observations = [SimpleNamespace(**dict(row)) for row in rows]
    with closing(sqlite3.connect(
        (root / 'dbase/occultations/observed.sdb').as_uri() + '?mode=ro', uri=True,
    )) as db:
        db.row_factory = sqlite3.Row
        row = db.execute(
            'SELECT * FROM occultations WHERE date=? AND sso=? AND star=?',
            (date, object_name, 'GDR3 0182009826266321792'),
        ).fetchone()
        if row is None or row['starmag'] > 7:
            raise ValueError('Bright 18 Aurigae component prediction missing')
        return observations, SimpleNamespace(**dict(row))


def damit_model(root):
    archive = root / 'media/damit'
    with (archive / 'tables/asteroids.csv').open(newline='') as stream:
        asteroid = next(row for row in csv.DictReader(stream) if row['number'] == '55')
    with (archive / 'tables/asteroid_models.csv').open(newline='') as stream:
        row = next(row for row in csv.DictReader(stream)
                   if row['asteroid_id'] == asteroid['id'] and row['id'] == '139')
    path = archive / 'files/asteroid_127/model_139/shape.txt'
    blob = path.read_bytes()
    return {
        'id': 139, 'calibrated': row['calibrated_size'] == '1', 'shape': blob.decode(),
        'spin': [float(row[key] or 0) for key in ('lambda', 'beta', 'period', 'jd0', 'phi0', 'yorp')],
    }, hashlib.sha256(blob).hexdigest()


def run(root, output):
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project.settings')
    os.environ.setdefault('MPLCONFIGDIR', '/tmp/simda-pandora-matplotlib')
    sys.path.insert(0, str(root))
    import django
    django.setup()
    import erfa
    import matplotlib
    matplotlib.use('Agg')
    from matplotlib import pyplot as plt
    import numpy as np
    from django.contrib.gis.geos import LineString, Point
    from cora.damit_profile import event_chords, fit_scale, register, silhouette
    from cora.fit_ellipse import fitellipse
    from cora.prediction_frames import true_elements
    from cora.views import _fp_chord_point

    rows, event = event_data(root)
    model, mesh_hash = damit_model(root)
    plane = true_elements(event)
    ignored = {str(n) for n, row in enumerate(rows, 1) if 'FIT_IGNORE' in (row.admnote or '')}
    chords, misses, epoch = event_chords(rows, 'occult', plane, ignored, _fp_chord_point)
    rings, measures = silhouette(model, plane, epoch, event.horpar, event.diam)
    baseline_center, baseline_rms = register(rings, [pair for _, pair in chords])
    center, scale, rms = fit_scale(rings, chords)
    limb = LineString((rings[0] * scale + center).tolist())
    assert len(rings) == 1 and len(chords) >= 3 and not misses

    contacts = np.asarray([pair for _, pair in chords]).reshape(-1, 2)
    ellipse_center, a, b, angle = fitellipse(contacts.T)
    a, b = abs(a), abs(b)
    ellipse_diameter = 2 * np.sqrt(a*b)
    theta = np.linspace(0, 2*np.pi, 361)
    rotation = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]])
    ellipse = np.column_stack((a*np.cos(theta), b*np.sin(theta))) @ rotation.T + ellipse_center

    output.mkdir(parents=True, exist_ok=True)
    results = []
    for number, (ingress, egress) in chords:
        row = rows[number-1]
        omitted = [chord for chord in chords if chord[0] != number]
        _, omitted_scale, _ = fit_scale(rings, omitted)
        results.append({
            'observation_id': row.id, 'cora_row': number,
            'ingress_utc': row.ut2, 'egress_utc': row.ut3,
            'ingress_sigma_s': row.ut2err, 'egress_sigma_s': row.ut3err,
            'ingress_x_km': ingress[0], 'ingress_y_km': ingress[1],
            'egress_x_km': egress[0], 'egress_y_km': egress[1],
            'ingress_limb_distance_km': limb.distance(Point(*ingress)),
            'egress_limb_distance_km': limb.distance(Point(*egress)),
            'volume_diameter_if_omitted_km': omitted_scale * measures['volume_diameter'],
        })
    with (output / 'chords.csv').open('w', newline='') as stream:
        writer = csv.DictWriter(stream, fieldnames=results[0], lineterminator='\n')
        writer.writeheader()
        writer.writerows(results)

    phase_checks = {}
    # The historical Occult figure labels a −70° phase offset. Software phase
    # conventions can differ, so try both signs without changing the main fit.
    for offset in (-70, 70):
        spin = model['spin'].copy()
        spin[4] += offset
        alt_rings, alt_measures = silhouette({**model, 'spin': spin}, plane, epoch,
                                             event.horpar, event.diam)
        _, alt_scale, alt_rms = fit_scale(alt_rings, chords)
        phase_checks[str(offset)] = {
            'volume_diameter_km': float(alt_scale * alt_measures['volume_diameter']),
            'endpoint_rms_km': float(alt_rms),
        }

    epoch_parts = erfa.jdcalf(7, epoch, 0)
    summary = {
        'prediction_id': event.id, 'gaia_star': event.star,
        'epoch_utc_jd': float(epoch), 'epoch_utc': f'{epoch_parts[0]:04}-{epoch_parts[1]:02}-{epoch_parts[2]:02}.{epoch_parts[3]:07}',
        'model_id': model['id'], 'mesh_sha256': mesh_hash, 'scipy_version': sys.modules['scipy'].__version__,
        'positive_chords': len(chords), 'recorded_misses': sum(row.detected == 'O-' for row in rows),
        'misses_used_in_fit': len(misses), 'translation_only_rms_km': float(baseline_rms),
        'fit_center_km': center.tolist(), 'fit_scale': float(scale), 'fit_rms_km': float(rms),
        'base_diameters_km': {key: float(value) for key, value in measures.items() if key.endswith('_diameter')},
        'fitted_diameters_km': {key: float(value * scale) for key, value in measures.items() if key.endswith('_diameter')},
        'ellipse_full_axes_km': sorted([2*a, 2*b], reverse=True),
        'ellipse_projected_diameter_km': float(ellipse_diameter),
        'phase_diagnostic_degrees': phase_checks,
        'leave_one_out_volume_km': [min(r['volume_diameter_if_omitted_km'] for r in results),
                                    max(r['volume_diameter_if_omitted_km'] for r in results)],
    }
    (output / 'result.json').write_text(json.dumps(summary, indent=2) + '\n')
    print(json.dumps(summary, indent=2))

    fig, ax = plt.subplots(figsize=(7, 6))
    def outline(points, **kwargs):
        ax.plot(*(points-center).T, **kwargs)
    for ring in rings:
        outline(ring + baseline_center, color='#71849a', linestyle=':', label='Original DAMIT scale, shifted')
        outline(ring * scale + center, color='#1d5576', linewidth=2, label='Fitted DAMIT outline')
    outline(ellipse, color='#a54d29', linestyle='--', label='Independent ellipse fit')
    numbered_endpoints = []
    for number, pair in chords:
        plotted = np.asarray(pair) - center
        ax.plot(*plotted.T, color='#2c353d', alpha=.8, lw=.9)
        ax.scatter(*plotted.T, color='#2c353d', s=11)
        numbered_endpoints.append((number, plotted[np.argmax(plotted[:, 0])]))
    last_y = -np.inf
    for number, (x, y) in sorted(numbered_endpoints, key=lambda entry: entry[1][1]):
        label_y = max(y, last_y + 2.8)
        ax.annotate(str(number), (x, y), xytext=(x+1.8, label_y), textcoords='data',
                    va='center', fontsize=8,
                    arrowprops=dict(arrowstyle='-', lw=.5, color='#7b8994') if label_y != y else None)
        last_y = label_y
    ax.set(title='(55) Pandora occultation of 18 Aurigae · 2019-12-07 UTC',
           xlabel='West of fitted model origin (km)', ylabel='North of fitted model origin (km)',
           aspect='equal')
    ax.legend(loc='upper right', fontsize=8)
    ax.grid(alpha=.2)
    ax.margins(.15)
    fig.tight_layout()
    fig.savefig(output / 'profile.png', dpi=180)
    plt.close(fig)


if __name__ == '__main__':
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--cora', type=Path,
                        default=Path(__file__).resolve().parents[3] / 'CORA/django')
    parser.add_argument('--output', type=Path, required=True)
    args = parser.parse_args()
    run(args.cora.resolve(), args.output.resolve())
