import { assertEquals, assertExists } from "@std/assert";
import {
  getUniqueFilename,
  getMimeType,
  isViewableInBrowser,
  formatFileSize,
  isAllowedFileType,
} from "../fileUtils.ts";

Deno.test("getMimeType - returns correct MIME type for images", () => {
  assertEquals(getMimeType("photo.jpg"), "image/jpeg");
  assertEquals(getMimeType("image.png"), "image/png");
  assertEquals(getMimeType("graphic.gif"), "image/gif");
  assertEquals(getMimeType("pic.webp"), "image/webp");
});

Deno.test("getMimeType - returns correct MIME type for videos", () => {
  assertEquals(getMimeType("video.mp4"), "video/mp4");
  assertEquals(getMimeType("clip.webm"), "video/webm");
  assertEquals(getMimeType("movie.avi"), "video/x-msvideo");
});

Deno.test("getMimeType - returns correct MIME type for documents", () => {
  assertEquals(getMimeType("document.pdf"), "application/pdf");
  assertEquals(getMimeType("readme.txt"), "text/plain");
  assertEquals(getMimeType("archive.zip"), "application/zip");
});

Deno.test("getMimeType - handles uppercase extensions", () => {
  assertEquals(getMimeType("PHOTO.JPG"), "image/jpeg");
  assertEquals(getMimeType("Video.MP4"), "video/mp4");
});

Deno.test("getMimeType - returns octet-stream for unknown types", () => {
  assertEquals(getMimeType("file.xyz"), "application/octet-stream");
  assertEquals(getMimeType("noextension"), "application/octet-stream");
});

Deno.test("isViewableInBrowser - images are viewable", () => {
  assertEquals(isViewableInBrowser("image/jpeg"), true);
  assertEquals(isViewableInBrowser("image/png"), true);
  assertEquals(isViewableInBrowser("image/gif"), true);
});

Deno.test("isViewableInBrowser - videos are viewable", () => {
  assertEquals(isViewableInBrowser("video/mp4"), true);
  assertEquals(isViewableInBrowser("video/webm"), true);
});

Deno.test("isViewableInBrowser - PDFs and text are viewable", () => {
  assertEquals(isViewableInBrowser("application/pdf"), true);
  assertEquals(isViewableInBrowser("text/plain"), true);
});

Deno.test("isViewableInBrowser - archives are not viewable", () => {
  assertEquals(isViewableInBrowser("application/zip"), false);
  assertEquals(isViewableInBrowser("application/octet-stream"), false);
});

Deno.test("formatFileSize - formats bytes correctly", () => {
  assertEquals(formatFileSize(0), "0 Bytes");
  assertEquals(formatFileSize(500), "500 Bytes");
  assertEquals(formatFileSize(1024), "1 KB");
  assertEquals(formatFileSize(1536), "1.5 KB");
  assertEquals(formatFileSize(1048576), "1 MB");
  assertEquals(formatFileSize(1073741824), "1 GB");
});

Deno.test("isAllowedFileType - allows configured types", () => {
  assertEquals(isAllowedFileType("image/jpeg"), true);
  assertEquals(isAllowedFileType("application/pdf"), true);
});

Deno.test("getUniqueFilename - returns same name if file doesn't exist", async () => {
  const testDir = await Deno.makeTempDir();

  try {
    // Save original config
    const { config } = await import("../config.ts");
    const originalUploadDir = config.uploadDir;
    config.uploadDir = testDir;

    const filename = await getUniqueFilename("test.txt");
    assertEquals(filename, "test.txt");

    // Restore
    config.uploadDir = originalUploadDir;
  } finally {
    await Deno.remove(testDir, { recursive: true });
  }
});

Deno.test("getUniqueFilename - appends epoch if file exists", async () => {
  const testDir = await Deno.makeTempDir();

  try {
    // Create a test file
    await Deno.writeTextFile(`${testDir}/existing.txt`, "test");

    const { config } = await import("../config.ts");
    const originalUploadDir = config.uploadDir;
    config.uploadDir = testDir;

    const filename = await getUniqueFilename("existing.txt");
    assertEquals(filename.startsWith("existing_"), true);
    assertEquals(filename.endsWith(".txt"), true);

    config.uploadDir = originalUploadDir;
  } finally {
    await Deno.remove(testDir, { recursive: true });
  }
});