package download

import (
	"context"
	"crypto/cipher"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"

	"golang.org/x/crypto/blowfish"
)

func TestDownloaderHasNoClientTimeout(t *testing.T) {
	d := NewWithOptions(true, false)
	if d.http.Timeout != 0 {
		t.Fatalf("http timeout = %v, want 0 (no global timeout)", d.http.Timeout)
	}
}

func TestDownloaderFile(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		_, _ = w.Write([]byte("abc123"))
	}))
	defer ts.Close()

	d := New()
	out := filepath.Join(t.TempDir(), "x", "a.bin")
	if err := d.File(context.Background(), ts.URL, out); err != nil {
		t.Fatalf("File() error = %v", err)
	}

	b, err := os.ReadFile(out)
	if err != nil {
		t.Fatalf("ReadFile() error = %v", err)
	}
	if string(b) != "abc123" {
		t.Fatalf("contents = %q, want %q", string(b), "abc123")
	}
}

func TestManifestDetection(t *testing.T) {
	if !isManifestResponse("application/dash+xml", []byte("x")) {
		t.Fatalf("expected dash content-type to be manifest")
	}
	if !isManifestResponse("application/octet-stream", []byte("<?xml version='1.0'?><MPD></MPD>")) {
		t.Fatalf("expected MPD XML body to be manifest")
	}
	if !isManifestResponse("text/plain", []byte("#EXTM3U\n#EXT-X-VERSION:3")) {
		t.Fatalf("expected HLS body to be manifest")
	}
	if isManifestResponse("audio/flac", []byte("fLaC")) {
		t.Fatalf("did not expect flac to be manifest")
	}
}

func TestNormalizeDeezerTrackID(t *testing.T) {
	if got := normalizeDeezerTrackID("https://www.deezer.com/track/3135556"); got != "3135556" {
		t.Fatalf("normalize track id = %q, want 3135556", got)
	}
}

func TestDecryptDeezerBFCBCStripe(t *testing.T) {
	trackID := "3135556"
	plain := make([]byte, deezerBFChunkSize*2)
	for i := range plain {
		plain[i] = byte(i % 251)
	}
	enc := make([]byte, len(plain))
	copy(enc, plain)
	block, err := blowfish.NewCipher(deriveDeezerBlowfishKey(trackID))
	if err != nil {
		t.Fatalf("cipher error: %v", err)
	}
	cbc := cipher.NewCBCEncrypter(block, deezerBFIV)
	cbc.CryptBlocks(enc[:deezerBFChunkSize], enc[:deezerBFChunkSize])

	dec, err := decryptDeezerBFCBCStripe(enc, trackID)
	if err != nil {
		t.Fatalf("decrypt error: %v", err)
	}
	if len(dec) != len(plain) || string(dec) != string(plain) {
		t.Fatalf("decrypted data mismatch")
	}
}

func TestFileDeezerEncrypted(t *testing.T) {
	trackID := "3135556"
	plain := make([]byte, deezerBFChunkSize+777)
	for i := range plain {
		plain[i] = byte((i * 7) % 251)
	}
	enc := make([]byte, len(plain))
	copy(enc, plain)

	block, err := blowfish.NewCipher(deriveDeezerBlowfishKey(trackID))
	if err != nil {
		t.Fatalf("cipher error: %v", err)
	}
	cbc := cipher.NewCBCEncrypter(block, deezerBFIV)
	cbc.CryptBlocks(enc[:deezerBFChunkSize], enc[:deezerBFChunkSize])

	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		_, _ = w.Write(enc)
	}))
	defer ts.Close()

	d := NewWithOptions(true, false)
	out := filepath.Join(t.TempDir(), "x", "a.flac")
	if err = d.FileDeezerEncrypted(context.Background(), ts.URL, out, trackID); err != nil {
		t.Fatalf("FileDeezerEncrypted() error = %v", err)
	}

	got, err := os.ReadFile(out)
	if err != nil {
		t.Fatalf("ReadFile() error = %v", err)
	}
	if string(got) != string(plain) {
		t.Fatalf("decrypted file mismatch")
	}
}