// Suggestion Engine for RFP Answer Enhancement

interface CompetitiveElement {
  keywords: string[];
  suggestions: string[];
}

interface CompanyProfile {
  name: string;
  experience: string;
  projectsCompleted: string;
  specializations: string[];
  certifications: string[];
  methodology: string[];
  teamSize: string;
  security: string[];
  timeline: string;
  pricing: string;
  staffingCapabilities?: {
    candidateDatabase: string;
    timeToFill: string;
    retentionRate: string;
    replacementGuarantee: string;
    skillLevels: string[];
    technologies: string[];
    clearances: string;
  };
}

interface AnalysisResult {
  qualityScore: number;
  strengths: string[];
  missingElements: string[];
  suggestions: string[];
  sednaEnhancements: string[];
}

interface RFPInsights {
  keyRequirements: string[];
  emphasizedAreas: string[];
  budgetIndicators: string[];
  timelineIndicators: string[];
  technologyMentions: string[];
  complianceRequirements: string[];
}

export class SuggestionEngine {
  private competitiveElements: Record<string, CompetitiveElement>;
  private companyProfile: CompanyProfile;

  constructor() {
    // Key elements that make RFP responses competitive
    this.competitiveElements = {
      experience: {
        keywords: ['years', 'experience', 'projects', 'delivered', 'successfully', 'track record'],
        suggestions: [
          'Add specific number of years of experience',
          'Include number of similar projects completed',
          'Mention client testimonials or case studies',
          'Highlight industry certifications'
        ]
      },
      methodology: {
        keywords: ['approach', 'methodology', 'process', 'framework', 'best practices'],
        suggestions: [
          'Detail your project management methodology (Agile, Waterfall, etc.)',
          'Include quality assurance processes',
          'Mention risk management strategies',
          'Describe testing and validation procedures'
        ]
      },
      security: {
        keywords: ['security', 'encryption', 'compliance', 'gdpr', 'soc', 'iso'],
        suggestions: [
          'Specify security certifications (SOC 2, ISO 27001)',
          'Detail encryption standards used',
          'Mention compliance frameworks (GDPR, HIPAA)',
          'Include penetration testing procedures'
        ]
      },
      team: {
        keywords: ['team', 'resources', 'staff', 'developers', 'architects'],
        suggestions: [
          'Provide team composition and roles',
          'Include team member certifications',
          'Mention relevant experience of key personnel',
          'Describe team scalability options'
        ]
      },
      timeline: {
        keywords: ['timeline', 'schedule', 'delivery', 'milestones', 'phases'],
        suggestions: [
          'Provide detailed project timeline',
          'Include milestone-based delivery approach',
          'Mention contingency planning for delays',
          'Describe parallel workstream capabilities'
        ]
      },
      cost: {
        keywords: ['cost', 'price', 'budget', 'value', 'roi'],
        suggestions: [
          'Provide transparent pricing model',
          'Include cost breakdown by phases',
          'Mention value-added services included',
          'Describe warranty and support terms'
        ]
      },
      technology: {
        keywords: ['technology', 'platform', 'architecture', 'integration', 'scalability'],
        suggestions: [
          'Detail technology stack and rationale',
          'Mention scalability and performance considerations',
          'Include integration capabilities',
          'Describe future-proofing strategies'
        ]
      },
      staffing: {
        keywords: ['staffing', 'recruitment', 'talent', 'candidates', 'placement', 'hire', 'augmentation'],
        suggestions: [
          'Highlight candidate database size and quality',
          'Include time-to-fill metrics and guarantees',
          'Mention retention rates and replacement policies',
          'Detail screening and vetting processes'
        ]
      }
    };

    this.companyProfile = {
      name: 'SEDNA Consulting Group',
      experience: '15+ years',
      projectsCompleted: '200+',
      specializations: ['enterprise digital transformation', 'healthcare', 'finance', 'manufacturing', 'IT staffing'],
      certifications: ['SOC 2', 'ISO 27001', 'GDPR'],
      methodology: ['Discovery', 'Design', 'Implementation', 'Testing', 'Deployment'],
      teamSize: '50+ professionals',
      security: ['end-to-end encryption', 'RBAC', 'security audits', 'penetration testing'],
      timeline: '18-week standard delivery',
      pricing: 'transparent fixed price with milestone billing',
      staffingCapabilities: {
        candidateDatabase: '2000+ qualified IT professionals',
        timeToFill: '48-72 hours initial submission',
        retentionRate: '90%+ placement retention',
        replacementGuarantee: '90-day no-cost replacement',
        skillLevels: ['Junior', 'Mid-level', 'Senior', 'Expert/Lead'],
        technologies: ['Full-stack Development', 'Cloud (AWS/Azure)', 'DevOps', 'Data Analytics', 'Cybersecurity', 'QA'],
        clearances: 'Security clearance capabilities available'
      }
    };
  }

  analyzeAnswer(question: string, answer: string, category = 'general'): AnalysisResult {
    const suggestions: string[] = [];
    const missingElements: string[] = [];
    const strengths: string[] = [];

    // Convert to lowercase for analysis
    const answerLower = answer.toLowerCase();
    const questionLower = question.toLowerCase();

    // Analyze coverage of competitive elements
    for (const [element, data] of Object.entries(this.competitiveElements)) {
      const hasKeywords = data.keywords.some((keyword: string) => 
        answerLower.includes(keyword) || questionLower.includes(keyword)
      );

      if (hasKeywords) {
        const coverage = this.calculateCoverage(answerLower, data.keywords);
        if (coverage < 0.3) { // Less than 30% keyword coverage
          missingElements.push(element);
          suggestions.push(...data.suggestions.slice(0, 2)); // Add top 2 suggestions
        } else {
          strengths.push(element);
        }
      }
    }

    // Add SEDNA-specific suggestions based on company profile
    const sednaSpecificSuggestions = this.generateSednaSpecificSuggestions(questionLower, answerLower);
    suggestions.push(...sednaSpecificSuggestions);

    // Quality score (0-100)
    const qualityScore = this.calculateQualityScore(answer, strengths.length, missingElements.length);

    return {
      qualityScore,
      strengths,
      missingElements,
      suggestions: this.removeDuplicates(suggestions),
      sednaEnhancements: this.getSednaEnhancements(questionLower)
    };
  }

  private calculateCoverage(text: string, keywords: string[]): number {
    const foundKeywords = keywords.filter((keyword: string) => text.includes(keyword));
    return foundKeywords.length / keywords.length;
  }

  private calculateQualityScore(answer: string, strengthsCount: number, missingCount: number): number {
    const baseScore = Math.min(answer.length / 10, 50); // Length-based score (max 50)
    const strengthBonus = strengthsCount * 8; // 8 points per strength
    const missingPenalty = missingCount * 5; // 5 points penalty per missing element
    
    return Math.max(0, Math.min(100, baseScore + strengthBonus - missingPenalty));
  }

  private generateSednaSpecificSuggestions(question: string, answer: string): string[] {
    const suggestions: string[] = [];

    // Experience-related suggestions
    if ((question.includes('experience') || question.includes('qualification')) && 
        !answer.includes('15') && !answer.includes('200')) {
      suggestions.push('Mention SEDNA\'s 15+ years of experience and 200+ completed projects');
    }

    // IT Staffing specific suggestions
    if (question.includes('staffing') || question.includes('recruitment') || question.includes('candidates')) {
      if (!answer.includes('2000')) {
        suggestions.push('Highlight SEDNA\'s database of 2000+ qualified IT professionals');
      }
      if (!answer.includes('48-72 hours')) {
        suggestions.push('Mention 48-72 hour response time for initial candidate submissions');
      }
      if (!answer.includes('90%')) {
        suggestions.push('Include 90%+ retention rate and 90-day replacement guarantee');
      }
    }

    // Time-to-fill and performance metrics
    if (question.includes('time') && question.includes('fill')) {
      suggestions.push('Emphasize SEDNA\'s rapid 48-72 hour initial candidate submission timeframe');
    }

    // Candidate quality and screening
    if (question.includes('quality') || question.includes('screening')) {
      suggestions.push('Detail SEDNA\'s comprehensive vetting process and quality assurance measures');
    }

    // Industry-specific suggestions
    if (question.includes('healthcare') && !answer.includes('healthcare')) {
      suggestions.push('Highlight SEDNA\'s healthcare industry expertise');
    }

    if (question.includes('finance') && !answer.includes('finance')) {
      suggestions.push('Emphasize SEDNA\'s financial services experience');
    }

    // Security-related suggestions
    if ((question.includes('security') || question.includes('compliance')) && 
        !answer.includes('soc 2')) {
      suggestions.push('Include SEDNA\'s SOC 2, ISO 27001, and GDPR compliance certifications');
    }

    // Methodology suggestions
    if ((question.includes('approach') || question.includes('methodology')) && 
        !answer.includes('discovery')) {
      suggestions.push('Detail SEDNA\'s 5-phase methodology: Discovery → Design → Implementation → Testing → Deployment');
    }

    // Team composition suggestions
    if (question.includes('team') && !answer.includes('project manager')) {
      suggestions.push('Describe SEDNA\'s standard team composition including PMP certified Project Manager');
    }

    return suggestions;
  }

  private getSednaEnhancements(question: string): string[] {
    const enhancements: string[] = [];

    // IT Staffing specific enhancements
    if (question.includes('staffing') || question.includes('recruitment') || question.includes('talent')) {
      enhancements.push(
        'SEDNA\'s comprehensive candidate database: 2000+ qualified IT professionals across all skill levels',
        'Rapid response time: Initial candidate submissions within 48-72 hours',
        'Proven retention: 90%+ placement retention rate with 90-day replacement guarantee',
        'Full-spectrum capabilities: Contract, contract-to-hire, and direct placement services',
        'Security clearance capabilities for government and defense contractor requirements'
      );
    }

    // Add specific SEDNA differentiators based on question type
    if (question.includes('why choose') || question.includes('competitive advantage')) {
      enhancements.push(
        'SEDNA\'s proven track record: 200+ successful projects across healthcare, finance, and manufacturing',
        'Multi-layered security approach with SOC 2 and ISO 27001 certifications',
        'Transparent pricing model with competitive rates and volume discounts'
      );
    }

    if (question.includes('experience') || question.includes('background')) {
      enhancements.push(
        '15+ years of experience in enterprise digital transformation and IT staffing',
        'Deep expertise across multiple industries: healthcare, finance, manufacturing',
        'Proven methodology for complex technology initiatives and staff augmentation'
      );
    }

    if (question.includes('timeline') || question.includes('delivery')) {
      enhancements.push(
        'SEDNA\'s standard 18-week delivery timeline with staged rollout approach',
        'Agile methodology with continuous integration and sprint reviews',
        'Risk mitigation through cross-trained team members and early API testing'
      );
    }

    if (question.includes('cost') || question.includes('pricing')) {
      enhancements.push(
        'Transparent pricing model with no hidden costs',
        'Monthly billing with milestone-based payments',
        'Includes 6-month warranty and support in base price',
        'Change management process for scope modifications'
      );
    }

    return enhancements;
  }

  private removeDuplicates(array: string[]): string[] {
    return [...new Set(array)];
  }

  // Analyze the entire RFP document for strategic insights
  analyzeRFPDocument(rfpContent: string): RFPInsights {
    const insights: RFPInsights = {
      keyRequirements: [],
      emphasizedAreas: [],
      budgetIndicators: [],
      timelineIndicators: [],
      technologyMentions: [],
      complianceRequirements: []
    };

    const contentLower = rfpContent.toLowerCase();

    // Extract key requirements (words that appear frequently)
    const words = contentLower.split(/\s+/);
    const wordFreq: Record<string, number> = {};
    words.forEach((word: string) => {
      if (word.length > 4) { // Only consider meaningful words
        wordFreq[word] = (wordFreq[word] || 0) + 1;
      }
    });

    // Get most frequent words as key requirements
    insights.keyRequirements = Object.entries(wordFreq)
      .sort(([,a], [,b]) => (b as number) - (a as number))
      .slice(0, 10)
      .map(([word]) => word);

    // Look for budget indicators
    const budgetPatterns = /\$[\d,]+|\d+k|\d+m|budget|cost|price/gi;
    insights.budgetIndicators = [...new Set(rfpContent.match(budgetPatterns) || [])] as string[];

    // Look for timeline indicators
    const timelinePatterns = /\d+\s*(weeks?|months?|days?)|deadline|delivery|timeline/gi;
    insights.timelineIndicators = [...new Set(rfpContent.match(timelinePatterns) || [])] as string[];

    // Technology mentions
    const techPatterns = /cloud|aws|azure|javascript|python|react|angular|api|database|sql/gi;
    insights.technologyMentions = [...new Set(rfpContent.match(techPatterns) || [])] as string[];

    // Compliance requirements
    const compliancePatterns = /gdpr|hipaa|soc\s*2|iso\s*27001|compliance|security|encryption/gi;
    insights.complianceRequirements = [...new Set(rfpContent.match(compliancePatterns) || [])] as string[];

    return insights;
  }
}

export const suggestionEngine = new SuggestionEngine();