package middleout

import (
    "bytes"
    "strings"
    "testing"
)

func TestMOSC(t *testing.T) {
    tests := []struct {
        name        string
        data        []byte
        spiralFactor float64
        clusterSize int
        maxFractal  int
    }{
        {
            name:        "Repetitive",
            data:        []byte(strings.Repeat("abcd", 6)), // 24 bytes
            spiralFactor: 0.1,
            clusterSize:  8,
            maxFractal:   3,
        },
        {
            name:        "Random",
            data:        []byte("abcdefghijklmnopqrstuvwxyz"), // 26 bytes
            spiralFactor: 0.1,
            clusterSize:  8,
            maxFractal:   3,
        },
        {
            name:        "Large",
            data:        []byte(strings.Repeat("abc", 100)), // 300 bytes
            spiralFactor: 0.1,
            clusterSize:  8,
            maxFractal:   3,
        },
        {
            name:        "Short",
            data:        []byte("abc"), // 3 bytes
            spiralFactor: 0.1,
            clusterSize:  8,
            maxFractal:   3,
        },
        {
            name:        "VeryLarge",
            data:        []byte(strings.Repeat("abcd", 1000)), // 4000 bytes
            spiralFactor: 0.1,
            clusterSize:  8,
            maxFractal:   0, // Disable fractal to isolate issue
        },
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            compressor := NewMOSCCompressor(tt.spiralFactor, tt.clusterSize, tt.maxFractal)
            compressed, err := compressor.Compress(tt.data)
            if err != nil {
                t.Fatalf("Compression error: %v", err)
            }
            t.Logf("Original size: %d bytes, Compressed size: %d bytes, Ratio: %.2f%%",
                len(tt.data), len(compressed), (float64(len(compressed))/float64(len(tt.data))*100))

            decompressed, err := compressor.Decompress(compressed)
            if err != nil {
                t.Fatalf("Decompression error: %v", err)
            }
            if !bytes.Equal(decompressed, tt.data) {
                t.Errorf("Decompressed data does not match original")
                logLen := len(decompressed)
                if logLen > 100 {
                    logLen = 100
                }
                t.Logf("Decompressed first %d bytes: %v", logLen, decompressed[:logLen])
                for i := 0; i < len(decompressed) && i < len(tt.data); i++ {
                    if decompressed[i] != tt.data[i] {
                        start := i - 5
                        if start < 0 {
                            start = 0
                        }
                        end := i + 5
                        if end > len(decompressed) {
                            end = len(decompressed)
                        }
                        if end > len(tt.data) {
                            end = len(tt.data)
                        }
                        t.Errorf("First mismatch at position %d: got %d, want %d; surrounding got %v, want %v",
                            i, decompressed[i], tt.data[i], decompressed[start:end], tt.data[start:end])
                        break
                    }
                }
            }
        })
    }
}