import tempfile
import unittest
from pathlib import Path

import laspy
import numpy as np
import rasterio
from pyproj import CRS
from rasterio.transform import from_origin

from B03_FileInput.B03_FileInput_Engine_Analyze import (
    analyze_input_metadata,
    analyze_las_metadata,
    analyze_prj_metadata,
    analyze_tfw_metadata,
    analyze_tif_metadata,
)


class AnalyzeLasMetadataTest(unittest.TestCase):
    def test_analyze_las_metadata(self) -> None:
        with tempfile.TemporaryDirectory() as temporary_directory:
            source = Path(temporary_directory) / "sample.las"
            las = laspy.LasData(laspy.LasHeader(point_format=3, version="1.2"))
            las.x = np.array([100.0, 102.0])
            las.y = np.array([200.0, 204.0])
            las.z = np.array([10.0, 14.0])
            las.classification = np.array([2, 5], dtype=np.uint8)
            las.write(source)

            metadata = analyze_las_metadata(source)

            self.assertEqual(metadata["file"], "sample.las")
            self.assertEqual(metadata["point_count"], 2)
            self.assertEqual(metadata["bounds"]["x"], [100.0, 102.0])
            self.assertEqual(metadata["bounds"]["y"], [200.0, 204.0])
            self.assertEqual(metadata["bounds"]["z"], [10.0, 14.0])
            self.assertEqual(metadata["classification_summary"], {"2": 1, "5": 1})

    def test_analyze_prj_metadata(self) -> None:
        with tempfile.TemporaryDirectory() as temporary_directory:
            source = Path(temporary_directory) / "result.prj"
            source.write_text(CRS.from_epsg(5179).to_wkt(), encoding="utf-8")

            metadata = analyze_prj_metadata(source)

            self.assertEqual(metadata["file"], "result.prj")
            self.assertEqual(metadata["epsg"], 5179)
            self.assertTrue(metadata["is_valid"])

            source.write_text("invalid wkt", encoding="utf-8")
            invalid_metadata = analyze_prj_metadata(source)
            self.assertFalse(invalid_metadata["is_valid"])
            self.assertIn("error", invalid_metadata)

    def test_analyze_tfw_metadata(self) -> None:
        with tempfile.TemporaryDirectory() as temporary_directory:
            source = Path(temporary_directory) / "result.tfw"
            source.write_text("0.5\n0\n0\n-0.5\n100\n200\n", encoding="utf-8")

            metadata = analyze_tfw_metadata(source)

            self.assertTrue(metadata["is_valid"])
            self.assertEqual(metadata["pixel_size_x"], 0.5)
            self.assertEqual(metadata["pixel_size_y"], -0.5)
            self.assertEqual(metadata["origin_x"], 100.0)
            self.assertEqual(metadata["origin_y"], 200.0)

            source.write_text("nan\n0\n0\n-0.5\n100\n200\n", encoding="utf-8")
            with self.assertRaises(ValueError):
                analyze_tfw_metadata(source)

    def test_analyze_tif_metadata(self) -> None:
        with tempfile.TemporaryDirectory() as temporary_directory:
            source = Path(temporary_directory) / "result.tif"
            with rasterio.open(
                source,
                mode="w",
                driver="GTiff",
                width=3,
                height=2,
                count=1,
                dtype="float32",
                crs="EPSG:5179",
                transform=from_origin(100, 200, 2, 2),
                nodata=-9999,
            ) as dataset:
                dataset.write(np.ones((1, 2, 3), dtype=np.float32))

            metadata = analyze_tif_metadata(source)

            self.assertEqual(metadata["file"], "result.tif")
            self.assertEqual(metadata["width"], 3)
            self.assertEqual(metadata["height"], 2)
            self.assertEqual(metadata["count"], 1)
            self.assertEqual(metadata["epsg"], 5179)
            self.assertEqual(metadata["resolution"], [2.0, 2.0])
            self.assertEqual(metadata["likely_type"], "dem")

    def test_analyze_input_metadata(self) -> None:
        with tempfile.TemporaryDirectory() as temporary_directory:
            source = Path(temporary_directory) / "drawing.dxf"
            source.write_bytes(b"0\nSECTION\n")

            metadata = analyze_input_metadata(source)

            self.assertEqual(
                metadata,
                {"file": "drawing.dxf", "extension": "dxf", "size_bytes": 10},
            )