"""Unit tests for formatting utilities."""

from abacus_common_logic.constants.math import Bytes
from abacus_common_logic.utils.formatting import format_bytes


class TestFormatBytes:
    """Tests for format_bytes function."""

    def test_format_bytes_small(self):
        """Test formatting small byte values."""
        assert format_bytes(0) == '0.00 B'
        assert format_bytes(1) == '1.00 B'
        assert format_bytes(512) == '512.00 B'
        assert format_bytes(1023) == '1023.00 B'

    def test_format_bytes_kilobytes(self):
        """Test formatting kilobyte values."""
        assert format_bytes(1024) == '1.00 KB'
        assert format_bytes(1536) == '1.50 KB'
        assert format_bytes(2048) == '2.00 KB'

    def test_format_bytes_megabytes(self):
        """Test formatting megabyte values."""
        assert format_bytes(1024**2) == '1.00 MB'
        assert format_bytes(int(1.5 * 1024**2)) == '1.50 MB'
        assert format_bytes(10 * 1024**2) == '10.00 MB'

    def test_format_bytes_gigabytes(self):
        """Test formatting gigabyte values."""
        assert format_bytes(1024**3) == '1.00 GB'
        assert format_bytes(int(2.5 * 1024**3)) == '2.50 GB'

    def test_format_bytes_negative(self):
        """Test formatting negative byte values."""
        assert format_bytes(-1024) == '-1.00 KB'
        assert format_bytes(-(1024**2)) == '-1.00 MB'

    def test_format_bytes_with_sign(self):
        """Test formatting with sign display."""
        assert format_bytes(1024, show_sign=True) == '+1.00 KB'
        assert format_bytes(-1024, show_sign=True) == '-1.00 KB'
        assert format_bytes(0, show_sign=True) == '0.00 B'

    def test_format_bytes_without_sign(self):
        """Test formatting without sign display."""
        assert format_bytes(1024, show_sign=False) == '1.00 KB'
        assert format_bytes(-1024, show_sign=False) == '-1.00 KB'

    def test_format_bytes_edge_cases(self):
        """Test edge cases for format_bytes."""
        # Just below 1 KB
        assert format_bytes(1023) == '1023.00 B'
        # Just at 1 KB
        assert format_bytes(1024) == '1.00 KB'
        # Just below 1 MB
        assert format_bytes(1024**2 - 1) == '1024.00 KB'
        # Just at 1 MB
        assert format_bytes(1024**2) == '1.00 MB'

    def test_format_bytes_precision(self):
        """Test that format_bytes maintains 2 decimal precision."""
        assert format_bytes(1234) == '1.21 KB'
        assert format_bytes(1234567) == '1.18 MB'
        assert format_bytes(1234567890) == '1.15 GB'

    def test_format_bytes_terabytes(self):
        """Test formatting terabyte values."""
        assert format_bytes(Bytes.TB) == '1.00 TB'
        assert format_bytes(int(2.5 * Bytes.TB)) == '2.50 TB'
        assert format_bytes(10 * Bytes.TB) == '10.00 TB'

    def test_format_bytes_petabytes(self):
        """Test formatting petabyte values."""
        assert format_bytes(Bytes.PB) == '1.00 PB'
        assert format_bytes(int(1.5 * Bytes.PB)) == '1.50 PB'
        assert format_bytes(5 * Bytes.PB) == '5.00 PB'

    def test_format_bytes_exabytes(self):
        """Test formatting exabyte values."""
        assert format_bytes(Bytes.EB) == '1.00 EB'
        assert format_bytes(int(3.14 * Bytes.EB)) == '3.14 EB'

    def test_format_bytes_zettabytes(self):
        """Test formatting zettabyte values."""
        assert format_bytes(Bytes.ZB) == '1.00 ZB'
        assert format_bytes(int(2.71 * Bytes.ZB)) == '2.71 ZB'

    def test_format_bytes_yottabytes(self):
        """Test formatting yottabyte values."""
        assert format_bytes(Bytes.YB) == '1.00 YB'
        assert format_bytes(int(1.23 * Bytes.YB)) == '1.23 YB'

    def test_format_bytes_all_units_with_constant(self):
        """Test all units using Bytes constants."""
        assert format_bytes(Bytes.B) == '1.00 B'
        assert format_bytes(Bytes.KB) == '1.00 KB'
        assert format_bytes(Bytes.MB) == '1.00 MB'
        assert format_bytes(Bytes.GB) == '1.00 GB'
        assert format_bytes(Bytes.TB) == '1.00 TB'
        assert format_bytes(Bytes.PB) == '1.00 PB'
        assert format_bytes(Bytes.EB) == '1.00 EB'
        assert format_bytes(Bytes.ZB) == '1.00 ZB'
        assert format_bytes(Bytes.YB) == '1.00 YB'

    def test_format_bytes_unit_boundaries(self):
        """Test values at unit boundaries."""
        # KB boundary
        assert format_bytes(Bytes.KB - 1) == '1023.00 B'
        assert format_bytes(Bytes.KB) == '1.00 KB'

        # MB boundary
        assert format_bytes(Bytes.MB - 1) == '1024.00 KB'
        assert format_bytes(Bytes.MB) == '1.00 MB'

        # GB boundary
        assert format_bytes(Bytes.GB - 1) == '1024.00 MB'
        assert format_bytes(Bytes.GB) == '1.00 GB'

        # TB boundary
        assert format_bytes(Bytes.TB - 1) == '1024.00 GB'
        assert format_bytes(Bytes.TB) == '1.00 TB'

    def test_format_bytes_large_negative_values(self):
        """Test large negative values."""
        assert format_bytes(-Bytes.TB) == '-1.00 TB'
        assert format_bytes(-Bytes.PB) == '-1.00 PB'
        assert format_bytes(-int(5.5 * Bytes.TB)) == '-5.50 TB'

    def test_format_bytes_very_large_with_sign(self):
        """Test very large values with sign display."""
        assert format_bytes(Bytes.EB, show_sign=True) == '+1.00 EB'
        assert format_bytes(Bytes.ZB, show_sign=True) == '+1.00 ZB'
        assert format_bytes(-Bytes.YB, show_sign=True) == '-1.00 YB'