package storage

import (
	"bytes"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func TestNew(t *testing.T) {
	dir := t.TempDir()
	s, err := New(dir)
	if err != nil {
		t.Fatalf("New: %v", err)
	}
	if s.basePath != dir {
		t.Fatalf("basePath = %q, want %q", s.basePath, dir)
	}
	// Verify directory was created.
	if _, err := os.Stat(dir); os.IsNotExist(err) {
		t.Fatal("storage directory was not created")
	}
}

func TestStoreAndOpen(t *testing.T) {
	dir := t.TempDir()
	s, _ := New(dir)

	data := []byte("hello world")
	hash, rel, err := s.Store(data, "txt")
	if err != nil {
		t.Fatalf("Store: %v", err)
	}
	if hash == "" {
		t.Fatal("expected non-empty hash")
	}
	if !strings.HasSuffix(rel, ".txt") {
		t.Fatalf("expected .txt extension, got %q", rel)
	}
	if !strings.HasPrefix(rel, hash[:2]+"/"+hash[2:4]+"/"+hash[4:6]+"/") {
		t.Fatalf("rel path %q does not match hash prefix", rel)
	}

	f, err := s.Open(rel)
	if err != nil {
		t.Fatalf("Open: %v", err)
	}
	defer f.Close()

	var buf bytes.Buffer
	buf.ReadFrom(f)
	if buf.String() != "hello world" {
		t.Fatalf("content = %q, want %q", buf.String(), "hello world")
	}

	// Check absolute path.
	abs := s.AbsPath(rel)
	if _, err := os.Stat(abs); os.IsNotExist(err) {
		t.Fatal("absolute path does not exist")
	}
}

func TestStoreAt(t *testing.T) {
	dir := t.TempDir()
	s, _ := New(dir)

	if err := s.StoreAt("custom/dir/file.txt", []byte("custom")); err != nil {
		t.Fatalf("StoreAt: %v", err)
	}

	data, err := os.ReadFile(filepath.Join(dir, "custom/dir/file.txt"))
	if err != nil {
		t.Fatalf("reading stored file: %v", err)
	}
	if string(data) != "custom" {
		t.Fatalf("content = %q", string(data))
	}
}

func TestDelete(t *testing.T) {
	dir := t.TempDir()
	s, _ := New(dir)

	_, rel, _ := s.Store([]byte("delete me"), "txt")

	if err := s.Delete(rel); err != nil {
		t.Fatalf("Delete: %v", err)
	}

	// File should be gone.
	abs := filepath.Join(dir, rel)
	if _, err := os.Stat(abs); !os.IsNotExist(err) {
		t.Fatal("file should be deleted")
	}
}

func TestDelete_NotFound(t *testing.T) {
	dir := t.TempDir()
	s, _ := New(dir)

	err := s.Delete("nonexistent/file.txt")
	if err == nil {
		t.Fatal("expected error deleting non-existent file")
	}
}

func TestStore_Duplicate(t *testing.T) {
	// Storing the same data twice should succeed (overwrites).
	dir := t.TempDir()
	s, _ := New(dir)

	hash1, _, _ := s.Store([]byte("same data"), "txt")
	hash2, rel2, _ := s.Store([]byte("same data"), "txt")

	if hash1 != hash2 {
		t.Fatal("same data should produce same hash")
	}

	// File should still be readable.
	f, _ := s.Open(rel2)
	defer f.Close()
	var buf bytes.Buffer
	buf.ReadFrom(f)
	if buf.String() != "same data" {
		t.Fatalf("content = %q", buf.String())
	}
}

func TestConsistentPartitioning(t *testing.T) {
	dir := t.TempDir()
	s, _ := New(dir)

	data := []byte("partition test")
	hash, rel, _ := s.Store(data, "dat")

	expected := hash[:2] + "/" + hash[2:4] + "/" + hash[4:6] + "/" + hash[:12] + ".dat"
	if rel != expected {
		t.Fatalf("rel = %q, want %q", rel, expected)
	}
}