import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { prisma } from '../db'
import {
  getCollaborators,
  updateCollaboratorPermission,
  removeCollaborator,
} from '../sharing-actions'
import bcrypt from 'bcryptjs'

describe('Collaborator Management', () => {
  let testUser1Id: string
  let testUser2Id: string
  let testListId: string
  let testCollaboratorId: string

  beforeAll(async () => {
    // Clean up any existing test data
    await prisma.collaborator.deleteMany({
      where: {
        user: {
          email: {
            in: ['collab-test1@example.com', 'collab-test2@example.com'],
          },
        },
      },
    })

    await prisma.list.deleteMany({
      where: {
        owner: {
          email: {
            in: ['collab-test1@example.com', 'collab-test2@example.com'],
          },
        },
      },
    })

    await prisma.user.deleteMany({
      where: {
        email: {
          in: ['collab-test1@example.com', 'collab-test2@example.com'],
        },
      },
    })

    // Create test users
    const hashedPassword = await bcrypt.hash('password123', 10)
    
    const user1 = await prisma.user.create({
      data: {
        email: 'collab-test1@example.com',
        name: 'Test User 1',
        passwordHash: hashedPassword,
      },
    })
    testUser1Id = user1.id

    const user2 = await prisma.user.create({
      data: {
        email: 'collab-test2@example.com',
        name: 'Test User 2',
        passwordHash: hashedPassword,
      },
    })
    testUser2Id = user2.id

    // Create a test list owned by user1
    const list = await prisma.list.create({
      data: {
        title: 'Test List',
        color: '#3b82f6',
        ownerId: testUser1Id,
      },
    })
    testListId = list.id

    // Create a collaborator (user2 on user1's list)
    const collaborator = await prisma.collaborator.create({
      data: {
        userId: testUser2Id,
        listId: testListId,
        permission: 'viewer',
      },
    })
    testCollaboratorId = collaborator.id
  })

  afterAll(async () => {
    // Clean up test data
    await prisma.collaborator.deleteMany({
      where: {
        user: {
          email: {
            in: ['collab-test1@example.com', 'collab-test2@example.com'],
          },
        },
      },
    })

    await prisma.list.deleteMany({
      where: {
        owner: {
          email: {
            in: ['collab-test1@example.com', 'collab-test2@example.com'],
          },
        },
      },
    })

    await prisma.user.deleteMany({
      where: {
        email: {
          in: ['collab-test1@example.com', 'collab-test2@example.com'],
        },
      },
    })
  })

  describe('getCollaborators', () => {
    it('should return all collaborators for a list', async () => {
      // Note: This test would need proper session mocking
      // For now, we're just testing the database query logic
      const collaborators = await prisma.collaborator.findMany({
        where: { listId: testListId },
        include: {
          user: {
            select: {
              id: true,
              name: true,
              email: true,
            },
          },
        },
      })

      expect(collaborators).toHaveLength(1)
      expect(collaborators[0].userId).toBe(testUser2Id)
      expect(collaborators[0].permission).toBe('viewer')
      expect(collaborators[0].user.email).toBe('collab-test2@example.com')
    })
  })

  describe('updateCollaboratorPermission', () => {
    it('should update collaborator permission from viewer to editor', async () => {
      // Update permission directly via Prisma (simulating the server action)
      const updated = await prisma.collaborator.update({
        where: {
          id: testCollaboratorId,
          listId: testListId,
        },
        data: {
          permission: 'editor',
        },
        include: {
          user: {
            select: {
              id: true,
              name: true,
              email: true,
            },
          },
        },
      })

      expect(updated.permission).toBe('editor')
      expect(updated.userId).toBe(testUser2Id)
    })

    it('should update collaborator permission from editor to viewer', async () => {
      // Update permission back to viewer
      const updated = await prisma.collaborator.update({
        where: {
          id: testCollaboratorId,
          listId: testListId,
        },
        data: {
          permission: 'viewer',
        },
      })

      expect(updated.permission).toBe('viewer')
    })
  })

  describe('removeCollaborator', () => {
    it('should remove a collaborator from a list', async () => {
      // First verify the collaborator exists
      const beforeDelete = await prisma.collaborator.findUnique({
        where: { id: testCollaboratorId },
      })
      expect(beforeDelete).not.toBeNull()

      // Delete the collaborator
      await prisma.collaborator.delete({
        where: {
          id: testCollaboratorId,
          listId: testListId,
        },
      })

      // Verify the collaborator is gone
      const afterDelete = await prisma.collaborator.findUnique({
        where: { id: testCollaboratorId },
      })
      expect(afterDelete).toBeNull()
    })
  })

  describe('Permission enforcement', () => {
    it('should enforce that only owners can manage collaborators', async () => {
      // Verify that the list has an owner
      const list = await prisma.list.findUnique({
        where: { id: testListId },
        select: { ownerId: true },
      })

      expect(list).not.toBeNull()
      expect(list?.ownerId).toBe(testUser1Id)
    })

    it('should validate permission values', async () => {
      // Test that only 'editor' and 'viewer' are valid permissions
      const validPermissions = ['editor', 'viewer']
      
      for (const permission of validPermissions) {
        // This should not throw
        expect(() => {
          if (permission !== 'editor' && permission !== 'viewer') {
            throw new Error('Invalid permission')
          }
        }).not.toThrow()
      }

      // Invalid permission should fail
      expect(() => {
        const invalidPermission = 'admin'
        if (invalidPermission !== 'editor' && invalidPermission !== 'viewer') {
          throw new Error('Invalid permission')
        }
      }).toThrow('Invalid permission')
    })
  })
})