import Testing
import SwiftData
@testable import BusinessCard

struct BusinessCardTests {

    @Test func vCardPayloadIncludesFields() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        let card = BusinessCard(
            displayName: "Test User",
            role: "Developer",
            company: "Test Corp",
            email: "test@example.com",
            phone: "+1 555 123 4567",
            website: "example.com",
            location: "San Francisco, CA"
        )
        context.insert(card)

        #expect(card.vCardPayload.contains("BEGIN:VCARD"))
        #expect(card.vCardPayload.contains("FN:\(card.displayName)"))
        #expect(card.vCardPayload.contains("ORG:\(card.company)"))
        #expect(card.vCardPayload.contains("EMAIL;TYPE=work:\(card.email)"))
        #expect(card.vCardPayload.contains("TEL;TYPE=work:\(card.phone)"))
    }

    @Test @MainActor func defaultCardSelectionUpdatesCards() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        BusinessCard.createSamples(in: context)
        try context.save()
        
        let store = CardStore(modelContext: context)
        let newDefault = store.cards[1]

        store.setDefaultCard(newDefault)

        #expect(store.selectedCardID == newDefault.id)
        #expect(store.cards.filter { $0.isDefault }.count == 1)
        #expect(store.cards.first { $0.isDefault }?.id == newDefault.id)
    }

    @Test @MainActor func contactsSearchFiltersByNameOrCompany() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        let contact1 = Contact(name: "John Doe", role: "Developer", company: "Global Bank")
        let contact2 = Contact(name: "Jane Smith", role: "Designer", company: "Tech Corp")
        context.insert(contact1)
        context.insert(contact2)
        try context.save()
        
        let store = ContactsStore(modelContext: context)
        store.searchQuery = "Global"

        #expect(store.visibleContacts.count == 1)
        #expect(store.visibleContacts.first?.company == "Global Bank")
    }
    
    @Test @MainActor func addCardIncreasesCardCount() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        let store = CardStore(modelContext: context)
        let initialCount = store.cards.count
        
        let newCard = BusinessCard(
            displayName: "New User",
            role: "Manager",
            company: "New Corp"
        )
        store.addCard(newCard)
        
        #expect(store.cards.count == initialCount + 1)
        #expect(store.selectedCardID == newCard.id)
    }
    
    @Test @MainActor func deleteCardRemovesFromStore() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        BusinessCard.createSamples(in: context)
        try context.save()
        
        let store = CardStore(modelContext: context)
        let initialCount = store.cards.count
        let cardToDelete = store.cards.last!
        
        store.deleteCard(cardToDelete)
        
        #expect(store.cards.count == initialCount - 1)
        #expect(!store.cards.contains(where: { $0.id == cardToDelete.id }))
    }
    
    @Test @MainActor func updateCardChangesProperties() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        let card = BusinessCard(
            displayName: "Original Name",
            role: "Original Role",
            company: "Original Company"
        )
        context.insert(card)
        try context.save()
        
        let store = CardStore(modelContext: context)
        
        card.displayName = "Updated Name"
        card.role = "Updated Role"
        store.updateCard(card)
        
        let updatedCard = store.cards.first(where: { $0.id == card.id })
        #expect(updatedCard?.displayName == "Updated Name")
        #expect(updatedCard?.role == "Updated Role")
    }
    
    @Test @MainActor func recordShareCreatesContact() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        let store = ContactsStore(modelContext: context)
        let initialCount = store.contacts.count
        
        store.recordShare(
            for: "New Contact",
            role: "CEO",
            company: "Partner Inc",
            cardLabel: "Work"
        )
        
        #expect(store.contacts.count == initialCount + 1)
        #expect(store.contacts.first?.name == "New Contact")
    }
    
    @Test @MainActor func recordShareUpdatesExistingContact() async throws {
        let container = try ModelContainer(for: BusinessCard.self, Contact.self)
        let context = container.mainContext
        
        let existingContact = Contact(
            name: "Existing Contact",
            role: "Manager",
            company: "Partner Inc",
            cardLabel: "Personal"
        )
        context.insert(existingContact)
        try context.save()
        
        let store = ContactsStore(modelContext: context)
        let initialCount = store.contacts.count
        
        store.recordShare(
            for: "Existing Contact",
            role: "Manager",
            company: "Partner Inc",
            cardLabel: "Work"
        )
        
        #expect(store.contacts.count == initialCount)
        let updated = store.contacts.first(where: { $0.name == "Existing Contact" })
        #expect(updated?.cardLabel == "Work")
    }
    
    @Test func themeAssignmentWorks() async throws {
        let card = BusinessCard()
        
        card.theme = .midnight
        #expect(card.themeName == "Midnight")
        #expect(card.theme.name == "Midnight")
        
        card.theme = .ocean
        #expect(card.themeName == "Ocean")
    }
    
    @Test func layoutStyleAssignmentWorks() async throws {
        let card = BusinessCard()
        
        card.layoutStyle = .split
        #expect(card.layoutStyleRawValue == "split")
        #expect(card.layoutStyle == .split)
        
        card.layoutStyle = .photo
        #expect(card.layoutStyleRawValue == "photo")
    }
}