import SwiftUI
import ComponentLibrary

struct IncomingMessage: View {
    let message: String
    let onLinkTap: ((String) -> Void)?
    let shouldAnimate: Bool
    
    @State private var typedMessage: String = ""
    @State private var hasAnimated: Bool = false
    
    init(message: String, onLinkTap: ((String) -> Void)? = nil, shouldAnimate: Bool = true) {
        self.message = message
        self.onLinkTap = onLinkTap
        self.shouldAnimate = shouldAnimate
    }
    
    var body: some View {
        let displayMessage = /*shouldAnimate ? typedMessage :*/ message
        
        HStack {
            if let onLinkTap = onLinkTap {
                AttributedMessageText(message: displayMessage, onLinkTap: onLinkTap)
                    .figmaMCPTypography(TypographyV1.FigmaMCP.mediumRegular)
                    .foregroundColor(.white)
                    .tracking(0.32)
                    .multilineTextAlignment(.leading)
            } else {
                Text(displayMessage)
                    .figmaMCPTypography(TypographyV1.FigmaMCP.mediumRegular)
                    .foregroundColor(.white)
                    .tracking(0.32)
                    .multilineTextAlignment(.leading)
            }
            
            Spacer()
        }
        .onAppear {
            if shouldAnimate && !hasAnimated {
                hasAnimated = true
                startTypingAnimation()
            } else {
                typedMessage = message
            }
        }
    }
    
    private func startTypingAnimation() {
        let characters = Array(message)
        let totalDuration: Double = 0.8 // Fast typing - 0.8 seconds total
        let intervalPerCharacter = totalDuration / Double(characters.count)
        
        typedMessage = ""
        
        for (index, character) in characters.enumerated() {
            DispatchQueue.main.asyncAfter(deadline: .now() + intervalPerCharacter * Double(index)) {
                typedMessage += String(character)
            }
        }
    }
}

struct AttributedMessageText: View {
    let message: String
    let onLinkTap: (String) -> Void
    
    var body: some View {
        // Parse markdown links like [Text](url) and make them clickable
        let parts = parseMarkdownLinks(message)
        
        HStack(alignment: .firstTextBaseline, spacing: 0) {
            ForEach(Array(parts.enumerated()), id: \.offset) { index, part in
                switch part {
                case .text(let text):
                    Text(text)
                case .link(let text, let url):
                    Text(text)
                        .foregroundColor(ChatConstants.Colors.Accent.brand)
                        .onTapGesture {
                            onLinkTap(url)
                        }
                }
            }
        }
    }
    private func parseMarkdownLinks(_ text: String) -> [MessagePart] {
        var parts: [MessagePart] = []
        var currentText = text
        
        while let linkRange = currentText.range(of: #"\[([^\]]+)\]\(([^)]+)\)"#, options: .regularExpression) {
            // Add text before the link
            let beforeLink = String(currentText[..<linkRange.lowerBound])
            if !beforeLink.isEmpty {
                parts.append(.text(beforeLink))
            }
            
            // Extract link text and URL
            let linkString = String(currentText[linkRange])
            if let textMatch = linkString.range(of: #"\[([^\]]+)\]"#, options: .regularExpression),
               let urlMatch = linkString.range(of: #"\(([^)]+)\)"#, options: .regularExpression) {
                let linkText = String(linkString[textMatch]).dropFirst().dropLast() // Remove [ ]
                let linkUrl = String(linkString[urlMatch]).dropFirst().dropLast()   // Remove ( )
                parts.append(.link(String(linkText), String(linkUrl)))
            }
            
            // Continue with remaining text
            currentText = String(currentText[linkRange.upperBound...])
        }
        
        // Add any remaining text
        if !currentText.isEmpty {
            parts.append(.text(currentText))
        }
        
        return parts
    }
}

enum MessagePart {
    case text(String)
    case link(String, String) // (display text, url)
}

#Preview {
    VStack(alignment: .leading, spacing: 16) {
        IncomingMessage(message: "Here you go, I made two versions of the song.\nLet me know what you want to make edits, I can also\ncreate more versions.")
        
        IncomingMessage(message: "Great choice! I'll create a upbeat song about friendship.")
        
        IncomingMessage(message: "Here are some lyrics I came up with:\n\nVerse 1:\nWe've been through it all together\nThrough the storms and sunny weather\nYou're the one I can depend on\nMy best friend until the end")
        
        Spacer()
    }
    .padding(.horizontal, 16)
    .background(ChatConstants.Colors.Background.primary)
    .frame(maxWidth: .infinity, maxHeight: .infinity)
}