app_for_reddit/Reddit App/Services/TitleOptimizationService.swift

import Foundation

protocol TitleOptimizationServiceProtocol: Sendable {
    func optimizeTitles(from draft: TitleDraft) async throws -> TitleOptimizationResult
}

enum TitleOptimizationError: LocalizedError {
    case emptyTopic
    case emptySubreddit
    case emptyTitle

    var errorDescription: String? {
        switch self {
        case .emptyTopic: "Enter a topic or keywords to guide title generation."
        case .emptySubreddit: "Enter a subreddit to tailor titles for that community."
        case .emptyTitle: "Enter a title to optimize, or provide a topic to generate from scratch."
        }
    }
}

struct MockTitleOptimizationService: TitleOptimizationServiceProtocol {
    func optimizeTitles(from draft: TitleDraft) async throws -> TitleOptimizationResult {
        guard !draft.subreddit.trimmingCharacters(in: .whitespaces).isEmpty else {
            throw TitleOptimizationError.emptySubreddit
        }
        guard !draft.topic.trimmingCharacters(in: .whitespaces).isEmpty else {
            throw TitleOptimizationError.emptyTopic
        }

        let hasTitle = !draft.originalTitle.trimmingCharacters(in: .whitespaces).isEmpty
        if !hasTitle {
            throw TitleOptimizationError.emptyTitle
        }

        try await Task.sleep(for: .milliseconds(900))

        let subreddit = draft.subreddit.replacingOccurrences(of: "r/", with: "")
        let topic = draft.topic.trimmingCharacters(in: .whitespaces)
        let original = draft.originalTitle.trimmingCharacters(in: .whitespaces)

        let analysis = analyzeTitle(original, goal: draft.titleGoal)
        let variants = makeVariants(
            original: original,
            topic: topic,
            subreddit: subreddit,
            tone: draft.tone,
            goal: draft.titleGoal,
            count: draft.variantCount.rawValue
        )

        return TitleOptimizationResult(analysis: analysis, variants: variants)
    }

    private func analyzeTitle(_ title: String, goal: TitleGoal) -> TitleAnalysis {
        let length = title.count
        let lengthScore = scoreLength(length)
        let engagementScore = scoreEngagement(title, goal: goal)
        let clarityScore = scoreClarity(title)
        let overall = (lengthScore + engagementScore + clarityScore) / 3
        let suggestions = makeSuggestions(title: title, length: length, goal: goal)

        return TitleAnalysis(
            overallScore: overall,
            lengthScore: lengthScore,
            engagementScore: engagementScore,
            clarityScore: clarityScore,
            suggestions: suggestions
        )
    }

    private func scoreLength(_ length: Int) -> Int {
        switch length {
        case 0: 0
        case 1...50: 95
        case 51...80: 85
        case 81...120: 70
        case 121...200: 50
        case 201...300: 30
        default: 10
        }
    }

    private func scoreEngagement(_ title: String, goal: TitleGoal) -> Int {
        var score = 50
        let lower = title.lowercased()

        if title.contains("?") { score += 10 }
        if title.range(of: #"\d+"#, options: .regularExpression) != nil { score += 8 }
        if lower.contains("how") || lower.contains("why") || lower.contains("what") { score += 6 }
        if lower.contains("you") || lower.contains("your") { score += 5 }
        if title == title.uppercased() && title.count > 5 { score -= 15 }

        switch goal {
        case .question where !title.contains("?"): score -= 10
        case .listicle where title.range(of: #"\d+"#, options: .regularExpression) == nil: score -= 8
        case .curiosity where !lower.contains("secret") && !lower.contains("nobody") && !lower.contains("actually"): score -= 3
        default: break
        }

        return min(100, max(0, score))
    }

    private func scoreClarity(_ title: String) -> Int {
        var score = 70
        let words = title.split(separator: " ").count

        if words >= 4 && words <= 12 { score += 15 }
        if words < 3 { score -= 20 }
        if words > 20 { score -= 15 }
        if title.contains("  ") { score -= 5 }
        if title.hasPrefix(" ") || title.hasSuffix(" ") { score -= 10 }

        return min(100, max(0, score))
    }

    private func makeSuggestions(title: String, length: Int, goal: TitleGoal) -> [String] {
        var tips: [String] = []

        if length > 120 {
            tips.append("Shorten to under 80 characters for better mobile visibility.")
        } else if length < 20 {
            tips.append("Add more context — very short titles can feel vague in feeds.")
        }

        if !title.contains("?") && goal == .question {
            tips.append("Reframe as a question to invite comments.")
        }

        if title.range(of: #"\d+"#, options: .regularExpression) == nil && goal == .listicle {
            tips.append("Include a number (e.g. \"5 tips\") for listicle-style engagement.")
        }

        let lower = title.lowercased()
        if goal == .curiosity && !lower.contains("?") {
            tips.append("Add a curiosity hook — hint at a surprising outcome.")
        }

        if tips.isEmpty {
            tips.append("Strong base title — try variants with different hooks below.")
        }

        return tips
    }

    private func makeVariants(
        original: String,
        topic: String,
        subreddit: String,
        tone: PostTone,
        goal: TitleGoal,
        count: Int
    ) -> [TitleVariant] {
        let templates = variantTemplates(
            original: original,
            topic: topic,
            subreddit: subreddit,
            tone: tone,
            goal: goal
        )

        return Array(templates.prefix(count)).enumerated().map { index, template in
            TitleVariant(
                title: template.title,
                score: template.score - index * 2,
                reasoning: template.reasoning
            )
        }
    }

    private func variantTemplates(
        original: String,
        topic: String,
        subreddit: String,
        tone: PostTone,
        goal: TitleGoal
    ) -> [(title: String, score: Int, reasoning: String)] {
        let base = original.isEmpty ? topic : original

        var results: [(title: String, score: Int, reasoning: String)] = []

        switch goal {
        case .curiosity:
            results = [
                ("The \(topic) trick nobody on r/\(subreddit) talks about", 92, "Curiosity gap with community reference"),
                ("I tried \(base) for 30 days — here's what actually happened", 89, "Personal experiment hook"),
                ("Why \(topic) is quietly changing everything (and most people miss it)", 87, "Insider knowledge angle"),
                ("\(base) — am I the only one who noticed this?", 84, "Relatability + intrigue"),
                ("What r/\(subreddit) taught me about \(topic) that I wish I knew sooner", 82, "Community wisdom framing"),
                ("The uncomfortable truth about \(topic)", 80, "Bold curiosity opener"),
                ("\(base): a deep dive you didn't know you needed", 78, "Value promise"),
                ("This \(topic) approach changed my mind completely", 76, "Transformation narrative"),
            ]
        case .question:
            results = [
                ("What's your experience with \(topic)?", 91, "Direct community question"),
                ("Am I wrong about \(base)?", 88, "Invites debate and replies"),
                ("How do you approach \(topic) on r/\(subreddit)?", 86, "Subreddit-specific ask"),
                ("Is \(topic) actually worth it in 2026?", 84, "Timely relevance question"),
                ("Anyone else struggling with \(base)?", 82, "Shared struggle hook"),
                ("What's the best \(topic) advice you've ever received?", 80, "Experience-sharing prompt"),
                ("\(base) — what am I missing here?", 78, "Humble knowledge seeker"),
                ("Hot take or common knowledge: \(topic)?", 76, "Opinion solicitation"),
            ]
        case .listicle:
            results = [
                ("7 \(topic) tips that actually work on r/\(subreddit)", 93, "Numbered list with community anchor"),
                ("5 mistakes everyone makes with \(base)", 90, "Problem-awareness listicle"),
                ("3 reasons \(topic) is underrated right now", 87, "Concise numbered hook"),
                ("10 things I learned about \(topic) the hard way", 85, "Lessons-learned format"),
                ("The top 5 \(topic) resources you need in 2026", 83, "Resource roundup angle"),
                ("\(base): 4 key takeaways from my experience", 81, "Summary-style list"),
                ("6 signs you're ready for \(topic)", 79, "Checklist engagement"),
                ("8 \(topic) hacks r/\(subreddit) swears by", 77, "Community-endorsed list"),
            ]
        case .emotional:
            results = [
                ("\(base) hit me harder than I expected", 91, "Emotional vulnerability"),
                ("I wasn't ready for what \(topic) taught me", 88, "Personal revelation"),
                ("This \(topic) moment changed everything for me", 86, "Transformation story"),
                ("Honestly, \(base) has been on my mind lately", 84, "Authentic confession"),
                ("The \(topic) journey nobody prepares you for", 82, "Empathy-driven framing"),
                ("Why \(base) still keeps me up at night", 80, "Emotional intensity"),
                ("\(topic) — a love letter to r/\(subreddit)", 78, "Community appreciation"),
                ("I finally understand \(base) and it's bittersweet", 76, "Reflective tone"),
            ]
        case .direct:
            results = [
                ("\(base) — a complete guide for r/\(subreddit)", 92, "Clear value proposition"),
                ("Everything you need to know about \(topic)", 89, "Comprehensive promise"),
                ("\(topic): what works, what doesn't, and why", 87, "Balanced direct framing"),
                ("My honest take on \(base)", 85, "Straightforward opinion"),
                ("\(topic) explained simply", 83, "Accessibility focus"),
                ("The definitive \(base) breakdown", 81, "Authority positioning"),
                ("\(topic) for beginners — start here", 79, "Audience targeting"),
                ("\(base): facts, not hype", 77, "No-nonsense angle"),
            ]
        case .provocative:
            results = [
                ("Unpopular opinion: \(base) is overrated", 93, "Classic debate starter"),
                ("\(topic) is a scam and here's why", 90, "Strong contrarian hook"),
                ("Hot take: r/\(subreddit) is wrong about \(topic)", 87, "Community challenge"),
                ("Stop doing \(base) — seriously", 85, "Command attention"),
                ("\(topic) culture has gone too far", 83, "Cultural critique"),
                ("I'll say it: \(base) isn't that impressive", 81, "Mild controversy"),
                ("Why everyone is sleeping on the real \(topic) issue", 79, "Contrarian insight"),
                ("\(base) — fight me", 77, "Maximum engagement bait"),
            ]
        }

        if tone == .humorous {
            results = results.map { variant in
                (title: variant.title + " 😅", score: variant.score - 3, reasoning: variant.reasoning + " (humorous tone)")
            }
        } else if tone == .professional {
            results = results.map { variant in
                (title: "[Analysis] " + variant.title, score: variant.score - 2, reasoning: variant.reasoning + " (professional tone)")
            }
        }

        return results.sorted { $0.score > $1.score }
    }
}