import { eq } from 'drizzle-orm';
import { deleteMedia } from '../src/actions/media';
import { db } from '../src/db';
import { users } from '../src/db/schema/auth';
import { media } from '../src/db/schema/media';
import { resources } from '../src/db/schema/resource';
import minioClient from '../src/lib/minio';
import { mediaBucketName } from '../src/lib/config';

async function upsertUser(email: string, name: string) {
  const [existing] = await db.select().from(users).where(eq(users.email, email)).limit(1);
  if (existing) return existing;
  const [created] = await db.insert(users).values({ email, name, passwordHash: 'test_password_hash' }).returning();
  return created;
}

async function runTest() {
  console.log('🧹 Testing media delete...');

  const owner = await upsertUser('media-delete-owner@ekb.com', 'Media Delete Owner');
  const outsider = await upsertUser('media-delete-outsider@ekb.com', 'Media Delete Outsider');
  const suffix = Date.now();
  const storageKey = `uploads/delete-test-${suffix}.txt`;

  const exists = await minioClient.bucketExists(mediaBucketName);
  if (!exists) await minioClient.makeBucket(mediaBucketName);
  await minioClient.putObject(mediaBucketName, storageKey, Buffer.from('delete test'));

  const [resource] = await db.insert(resources).values({
    name: `delete-test-${suffix}.txt`,
    path: `/delete-test/${suffix}.txt`,
    type: 'file',
    ownerId: owner.id,
  }).returning();

  const [mediaRecord] = await db.insert(media).values({
    resourceId: resource.id,
    filename: `delete-test-${suffix}.txt`,
    storageKey,
    mimeType: 'text/plain',
    size: BigInt(11),
    status: 'completed',
  }).returning();

  try {
    await deleteMedia(mediaRecord.id, { auth: { userId: outsider.id, groupIds: [] } });
    console.error('❌ Outsider unexpectedly deleted media.');
    process.exit(1);
  } catch {
    // Expected.
  }

  const result = await deleteMedia(mediaRecord.id, { auth: { userId: owner.id, groupIds: [] } });
  const [deletedMedia] = await db.select().from(media).where(eq(media.id, mediaRecord.id)).limit(1);
  const [deletedResource] = await db.select().from(resources).where(eq(resources.id, resource.id)).limit(1);

  if (!result.deleted || deletedMedia || deletedResource) {
    console.error('❌ Media delete did not remove expected database rows.');
    process.exit(1);
  }

  console.log('✅ Media delete passed.');
  process.exit(0);
}

runTest().catch((error) => {
  console.error('❌ Test failed with error:', error);
  process.exit(1);
});