"""Local tests for publication guards. No network requests or real uploads."""
import contextlib
import hashlib
import importlib.util
import io
import json
from pathlib import Path
import sys
import tempfile
import unittest
from unittest.mock import Mock, patch


ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location('release_uploader', ROOT / 'upload_dataset.py')
uploader = importlib.util.module_from_spec(spec)
spec.loader.exec_module(uploader)


class UploadGuards(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.addCleanup(self.temp.cleanup)
        self.root = Path(self.temp.name).resolve()
        self.plan = {'repo_id': 'test_user/new_dataset', 'parquet_files': 1, 'parquet_bytes': 4, 'parquet_GiB': 4 / 2**30}
        payloads = {
            'upload_plan.json': json.dumps(self.plan).encode(),
            'validation.json': json.dumps({'status': 'passed', 'files': 1, 'parquet_bytes': 4}).encode(),
            'test.parquet': b'test',
        }
        entries = []
        for name, payload in payloads.items():
            (self.root / name).write_bytes(payload)
            entries.append({'path': name, 'bytes': len(payload), 'sha256': hashlib.sha256(payload).hexdigest()})
        inventory = {'algorithm': 'SHA256', 'files': entries, 'file_count': len(entries), 'total_bytes': sum(e['bytes'] for e in entries)}
        (self.root / 'release_inventory.json').write_text(json.dumps(inventory))

    def test_default_dry_run_does_not_open_network_client(self):
        with patch('huggingface_hub.HfApi', side_effect=AssertionError('Network client opened')):
            with patch.object(sys, 'argv', ['upload_dataset.py', '--data-dir', str(self.root)]):
                with contextlib.redirect_stdout(io.StringIO()) as output:
                    uploader.main()
        self.assertIn('local_dry_run', output.getvalue())
        self.assertFalse((self.root / 'upload_state.json').exists())

    def test_same_size_data_change_fails_hash_check(self):
        (self.root / 'test.parquet').write_bytes(b'edit')
        with self.assertRaisesRegex(ValueError, 'SHA256 mismatch'):
            uploader.check_release(self.root, verify_hashes=True)

    def test_unlisted_file_is_rejected(self):
        (self.root / 'extra.txt').write_text('unlisted')
        with self.assertRaisesRegex(ValueError, 'Inventory differs'):
            uploader.check_release(self.root)

    def test_existing_repository_is_never_replaced_on_fresh_run(self):
        api = Mock()
        api.whoami.return_value = {'name': 'test_user'}
        api.repo_info.return_value = Mock(private=False)
        with patch('huggingface_hub.HfApi', return_value=api):
            with self.assertRaisesRegex(ValueError, 'Repository already exists'):
                uploader.publish(self.root, self.plan['repo_id'], [], resume=False, workers=1)
        api.create_repo.assert_not_called()
        api.upload_large_folder.assert_not_called()
        api.upload_folder.assert_not_called()

    def test_resume_requires_matching_local_state(self):
        api = Mock()
        api.whoami.return_value = {'name': 'test_user'}
        api.repo_info.return_value = Mock(private=False)
        with patch('huggingface_hub.HfApi', return_value=api):
            with self.assertRaisesRegex(ValueError, 'Resume requires'):
                uploader.publish(self.root, self.plan['repo_id'], [], resume=True, workers=1)
        api.create_repo.assert_not_called()
        api.upload_large_folder.assert_not_called()


if __name__ == '__main__':
    unittest.main()