import base64
from pathlib import Path
import struct
import tempfile
import unittest
from unittest.mock import patch
import zlib
from app import Dataset, ReviewError
from test_app import request_without_socket


def skin_png(color=b'\x10\x80\x40\xff'):
    def chunk(tag, payload):
        return struct.pack('>I', len(payload)) + tag + payload + struct.pack('>I', zlib.crc32(tag + payload))
    return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 64, 64, 8, 6, 0, 0, 0)) + chunk(b'IDAT', zlib.compress((b'\0' + color * 64) * 64)) + chunk(b'IEND', b'')


class PerfectTest(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.root = Path(self.temp.name)
        for name in ['A_source.png', 'A_edited.png', 'A_result.png', 'A_result_v2.png']:
            (self.root / name).write_bytes(skin_png())
        self.data = Dataset(self.root)
        self.key = next(iter(self.data.records))

    def tearDown(self):
        self.temp.cleanup()

    def state(self):
        return self.data.state()['items'][0]

    def save(self, kind, **values):
        return request_without_socket(self.data, '/api/' + kind, {'key': self.key, 'revision': self.state()['revision'], 'result': 'A_result.png', **values})

    def test_perfect_and_repair_persist_and_stale_revision(self):
        self.assertEqual(self.save('perfect')['status'], 200)
        for suffix in ['best', 'perfect']:
            self.assertEqual((self.root / f'A_{suffix}.txt').read_text(), 'A_result.png\n')
        self.assertFalse((self.root / 'A_perfect.png').exists())
        old = self.state()['revision']
        png = skin_png(b'\xff\x00\x00\xff')
        result = self.save('repair', png='data:image/png;base64,' + base64.b64encode(png).decode())
        self.assertEqual(result['status'], 200)
        self.assertEqual((self.root / 'A_perfect.png').read_bytes(), png)
        self.assertNotEqual(old, self.state()['revision'])
        self.assertEqual(self.save('perfect', revision=old)['status'], 409)
        fresh = Dataset(self.root)
        self.assertEqual(fresh.state()['items'][0]['perfect'], 'A_result.png')
        self.assertEqual(fresh.resolve_media('A_perfect.png').read_bytes(), png)
        self.assertEqual((self.root / 'A_result.png').read_bytes(), skin_png())

    def test_invalid_png_and_missing_candidate_do_not_write(self):
        for value in [None, '', 'data:image/png;base64,AAAA', 'data:image/png;base64,' + base64.b64encode(skin_png()[:-5]).decode()]:
            self.assertEqual(self.save('repair', png=value)['status'], 400)
        self.assertEqual(self.save('perfect', result='../A_result.png')['status'], 400)
        self.assertFalse((self.root / 'A_best.txt').exists())
        self.assertFalse((self.root / 'A_perfect.txt').exists())
        self.assertFalse((self.root / 'A_perfect.png').exists())

    def test_reselect_clear_and_reject_remove_perfect(self):
        for kind in ['choose', 'perfect', 'clear', 'reject']:
            self.save('repair', png='data:image/png;base64,' + base64.b64encode(skin_png()).decode())
            self.assertEqual(self.save(kind, reason='result_unsatisfied')['status'], 200)
            self.assertFalse((self.root / 'A_perfect.png').exists())
            self.assertEqual((self.root / 'A_perfect.txt').exists(), kind == 'perfect')

    def test_perfect_symlinks_rejected(self):
        outside = self.root / 'untouched.txt'
        outside.write_text('untouched')
        for name in ['A_perfect.txt', 'A_perfect.png']:
            link = self.root / name
            link.symlink_to(outside)
            with self.assertRaises(ReviewError):
                self.data.save_annotation(self.key, 'missing', 'perfect', 'A_result.png')
            self.assertEqual(outside.read_text(), 'untouched')
            link.unlink()

    def test_failed_second_write_rolls_back_repair(self):
        self.save('repair', png='data:image/png;base64,' + base64.b64encode(skin_png()).decode())
        previous = {p.name: p.read_bytes() for p in self.root.iterdir()}
        with patch.object(self.data, 'write_annotation', side_effect=OSError('disk full')):
            result = self.save('repair', png='data:image/png;base64,' + base64.b64encode(skin_png(b'\xff\x00\x00\xff')).decode())
        self.assertEqual(result['status'], 400)
        self.assertEqual(previous, {p.name: p.read_bytes() for p in self.root.iterdir()})