"""Profile the phase of Pandora's DAMIT model against the ten positive chords."""
import argparse
import csv
import hashlib
import json
import os
from pathlib import Path
import sys
import xml.etree.ElementTree as ET


def archive_event(cora_root):
    source = cora_root / 'dbase/observations/occult/Asteroid-Observations.xml'
    content = source.read_bytes()
    root = ET.fromstring(content)
    events = [
        event for event in root.findall('Event')
        if [x.strip() for x in event.findtext('Date', '').split('|')[:3]] == ['2019', '12', '7']
        and event.findtext('.//Asteroid', '').startswith('55|Pandora|')
    ]
    event, = events
    miss_markers = []
    for observer in event.findall('Observations/Observer'):
        ingress, egress = (observer.findtext(key, '').split('|') for key in ('D', 'R'))
        if ingress[1] == egress[1] == 'M':
            assert ingress[0].strip() == egress[0].strip()
            miss_markers.append(ingress[0].strip())
    return {
        'file_version': root.findtext('FileVersion'),
        'archive_sha256': hashlib.sha256(content).hexdigest(),
        'miss_markers_utc': miss_markers,
        'start_end_coverage_available': False,
        'ellipse': event.findtext('.//EllipticFit').split('|'),
        'ellipse_uncertainty': event.findtext('.//EllipseUncertainty').split('|'),
        'solve_flags': event.findtext('.//SolveFlags').split('|'),
        'shape_model_fit': event.findtext('.//ShapeModelFit/Fit').split('|'),
    }


def run(cora_root, output):
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project.settings')
    os.environ.setdefault('MPLCONFIGDIR', '/tmp/simda-pandora-matplotlib')
    sys.path.insert(0, str(cora_root))
    import django
    django.setup()
    import matplotlib
    matplotlib.use('Agg')
    from matplotlib import pyplot as plt
    import numpy as np
    from scipy.optimize import minimize_scalar
    from cora.damit_profile import event_chords, fit_scale, silhouette
    from cora.prediction_frames import true_elements
    from cora.views import _fp_chord_point

    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
    import fit_2019 as v1
    rows, event = v1.event_data(cora_root)
    model, mesh_sha256 = v1.damit_model(cora_root)
    archive = archive_event(cora_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)
    assert len(chords) == 10 and not misses and len(archive['miss_markers_utc']) == 4

    def fit(offset, subset=chords):
        spin = model['spin'].copy()
        spin[4] += offset
        rings, diam = silhouette({**model, 'spin': spin}, plane, epoch, event.horpar, event.diam)
        center, scale, rms = fit_scale(rings, subset)
        return {
            'phase_deg': float((offset + 180) % 360 - 180),
            'rms_km': float(rms), 'scale': float(scale), 'center_km': center.tolist(),
            **{key + '_km': float(scale * value) for key, value in diam.items() if key.endswith('_diameter')},
        }

    def refine(offset, subset=chords):
        result = minimize_scalar(lambda trial: fit(trial, subset)['rms_km'],
                                 bounds=(offset-5, offset+5), method='bounded',
                                 options={'xatol': .05})
        if not result.success:
            raise RuntimeError('Phase refinement did not converge')
        return min((fit(result.x, subset), fit(offset, subset)), key=lambda row: row['rms_km'])

    grid = [fit(offset) for offset in range(-180, 180, 5)]
    minima = [refine(row['phase_deg']) for i,row in enumerate(grid)
              if row['rms_km'] < min(grid[i-1]['rms_km'], grid[(i+1)%len(grid)]['rms_km'])]
    minima.sort(key=lambda row: row['rms_km'])
    best = minima[0]
    jackknife = [
        {'observation_id': rows[number-1].id,
         **refine(best['phase_deg'], [chord for chord in chords if chord[0] != number])}
        for number,_ in chords
    ]
    summary = {
        'fit': best, 'local_minima': minima, 'jackknife_same_basin': jackknife,
        'prediction_id': event.id, 'mesh_sha256': mesh_sha256, 'archive': archive,
        'positive_chords': len(chords), 'misses_used': 0,
    }
    output.mkdir(parents=True, exist_ok=True)
    (output / 'result.json').write_text(json.dumps(summary, indent=2)+'\n')
    with (output / 'phase_profile.csv').open('w', newline='') as stream:
        writer = csv.DictWriter(stream, fieldnames=grid[0], lineterminator='\n')
        writer.writeheader()
        writer.writerows(grid)
    fig, (upper, lower) = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
    x = [p['phase_deg'] for p in grid]
    upper.plot(x, [p['rms_km'] for p in grid], color='#185072')
    lower.plot(x, [p['volume_diameter_km'] for p in grid], color='#843a21')
    for axis, key in ((upper, 'rms_km'), (lower, 'volume_diameter_km')):
        axis.scatter([p['phase_deg'] for p in minima], [p[key] for p in minima], color='#282828', s=18, zorder=3)
        axis.axvline(best['phase_deg'], color='#6a6a6a', linestyle=':')
        axis.grid(alpha=.2)
    upper.set(title='(55) Pandora · 2019 occultation · DAMIT model 139',
              ylabel='Positive endpoint RMS (km)')
    lower.set(xlabel='Offset from published rotation phase (degrees)',
              ylabel='Volume-equivalent diameter (km)', xlim=(-180,180))
    fig.tight_layout()
    fig.savefig(output/'phase_profile.png', dpi=180)
    plt.close(fig)
    print(json.dumps({'fit':best,'local_minima':minima,'miss_markers':archive['miss_markers_utc'],
                      'jackknife_volume': [min(r['volume_diameter_km'] for r in jackknife),
                                           max(r['volume_diameter_km'] for r in jackknife)]}, indent=2))


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