// Grok AI的UX评估关键指标
const uxMetrics = {
  visualDesign: {
    modernization: 'assessment_score',
    consistency: 'design_system_evaluation',
    accessibility: 'wcag_compliance_check'
  },
  responsiveDesign: {
    mobileOptimization: 'mobile_first_analysis',
    crossBrowserCompatibility: 'browser_testing_results',
    performanceImpact: 'responsive_performance_metrics'
  },
  navigationStructure: {
    userFlow: 'navigation_path_analysis',
    searchability: 'search_functionality_audit',
    breadcrumbs: 'navigation_hierarchy_review'
  }
}

interface ContentAnalysis {
  structure: {
    hierarchyScore: number;
    categorization: string[];
    contentDepth: 'shallow' | 'moderate' | 'deep';
  };
  freshness: {
    updateFrequency: string;
    lastModified: Date;
    contentAge: number;
  };
  engagement: {
    readabilityScore: number;
    averageTimeOnPage: number;
    bounceRate: number;
  };
}

// Grok AI内容分析示例
const contentAssessment: ContentAnalysis = {
  structure: {
    hierarchyScore: 6,
    categorization: ['tech', 'blog', 'education', 'experiences'],
    contentDepth: 'moderate'
  },
  freshness: {
    updateFrequency: 'irregular',
    lastModified: new Date('2024-08-01'),
    contentAge: 28
  },
  engagement: {
    readabilityScore: 7.2,
    averageTimeOnPage: 180,
    bounceRate: 0.45
  }
}

// 技术栈评估配置
const techStackAnalysis = {
  framework: 'Next.js 15+',
  renderingStrategy: 'SSR + ISR',
  performance: {
    coreWebVitals: {
      LCP: 2.1, // Largest Contentful Paint
      FID: 85,  // First Input Delay
      CLS: 0.08 // Cumulative Layout Shift
    },
    lighthouse: {
      performance: 88,
      accessibility: 91,
      bestPractices: 85,
      seo: 72
    }
  },
  architecture: {
    componentStructure: 'well_organized',
    stateManagement: 'react_hooks',
    apiIntegration: 'server_actions'
  }
}

// SEO元数据配置示例
interface SEOConfiguration {
  metadata: {
    title: string;
    description: string;
    keywords: string[];
    openGraph: OpenGraphConfig;
    structuredData: StructuredDataConfig;
  };
  technicalSEO: {
    sitemap: boolean;
    robotsTxt: boolean;
    canonicalUrls: boolean;
    hreflangTags: boolean;
  };
  performance: {
    imageOptimization: boolean;
    codesplitting: boolean;
    caching: CacheStrategy;
  };
}

const currentSEOSetup: SEOConfiguration = {
  metadata: {
    title: "动态生成，需要优化",
    description: "基本配置存在，但可以更精确",
    keywords: ["部分关键词缺失"],
    openGraph: {
      configured: true,
      imageOptimized: false
    },
    structuredData: {
      implemented: false, // 主要缺失项
      schemas: []
    }
  },
  technicalSEO: {
    sitemap: true,
    robotsTxt: true,
    canonicalUrls: true,
    hreflangTags: true // 多语言优势
  },
  performance: {
    imageOptimization: true,
    codesplitting: true,
    caching: {
      strategy: 'ISR',
      revalidation: 86400
    }
  }
}

# 安装必要的分析依赖
npm install lighthouse puppeteer axe-core
npm install @google/generative-ai # 用于AI分析集成
npm install web-vitals # 性能指标监测

# 配置分析脚本
mkdir website-analysis
cd website-analysis
touch grok-analysis.js lighthouse-config.js

// grok-analysis.js
import { GoogleGenerativeAI } from '@google/generative-ai';
import lighthouse from 'lighthouse';
import puppeteer from 'puppeteer';

class GrokWebsiteAnalyzer {
  constructor(apiKey) {
    this.genAI = new GoogleGenerativeAI(apiKey);
    this.model = this.genAI.getGenerativeModel({ model: "gemini-pro" });
  }

  async analyzeWebsite(url) {
    const analysisPrompt = `
      请分析以下网站的各个方面：
      URL: ${url}
      
      请从以下维度进行分析：
      1. 设计与用户体验 (满分10分)
      2. 内容质量 (满分10分)
      3. 技术实现 (满分10分)
      4. SEO基础 (满分10分)
      
      对每个维度提供具体的评分理由和改进建议。
    `;

    try {
      const result = await this.model.generateContent(analysisPrompt);
      return this.parseAnalysisResult(result.response.text());
    } catch (error) {
      console.error('Grok分析失败:', error);
      throw error;
    }
  }

  parseAnalysisResult(analysisText) {
    // 解析AI分析结果的结构化数据
    const sections = analysisText.split(/\d+\.\s+/);
    return {
      designUX: this.extractScoreAndFeedback(sections[1]),
      contentQuality: this.extractScoreAndFeedback(sections[2]),
      technicalImplementation: this.extractScoreAndFeedback(sections[3]),
      seoFoundation: this.extractScoreAndFeedback(sections[4])
    };
  }

  extractScoreAndFeedback(section) {
    const scoreMatch = section.match(/(\d+)\/10/);
    const score = scoreMatch ? parseInt(scoreMatch[1]) : 0;
    const feedback = section.replace(/.*?(\d+\/10)/, '').trim();
    
    return { score, feedback };
  }
}

// performance-analyzer.js
import { getCLS, getFID, getFCP, getLCP, getTTFB } from 'web-vitals';

class PerformanceAnalyzer {
  constructor() {
    this.metrics = {};
  }

  async gatherWebVitals() {
    return new Promise((resolve) => {
      getCLS((metric) => this.metrics.cls = metric.value);
      getFID((metric) => this.metrics.fid = metric.value);
      getFCP((metric) => this.metrics.fcp = metric.value);
      getLCP((metric) => this.metrics.lcp = metric.value);
      getTTFB((metric) => this.metrics.ttfb = metric.value);

      // 等待所有指标收集完成
      setTimeout(() => resolve(this.metrics), 3000);
    });
  }

  async runLighthouseAudit(url) {
    const browser = await puppeteer.launch({
      headless: true,
      args: ['--no-sandbox', '--disable-dev-shm-usage']
    });

    const results = await lighthouse(url, {
      port: new URL(browser.wsEndpoint()).port,
      output: 'json',
      logLevel: 'info',
      disableDeviceEmulation: true,
      chromeFlags: ['--disable-mobile-emulation']
    });

    await browser.close();
    return results;
  }

  analyzePerformanceGaps(metrics) {
    const recommendations = [];

    if (metrics.lcp > 2500) {
      recommendations.push({
        issue: 'LCP过慢',
        solution: '优化关键资源加载，使用图片预加载',
        priority: 'high'
      });
    }

    if (metrics.fid > 100) {
      recommendations.push({
        issue: 'FID响应慢',
        solution: '减少JavaScript执行时间，优化事件处理',
        priority: 'medium'
      });
    }

    if (metrics.cls > 0.1) {
      recommendations.push({
        issue: 'CLS布局偏移',
        solution: '为图片和广告设置固定尺寸',
        priority: 'high'
      });
    }

    return recommendations;
  }
}

// seo-analyzer.ts
interface SEOAuditResult {
  technicalSEO: TechnicalSEOScore;
  contentOptimization: ContentSEOScore;
  structuredData: StructuredDataScore;
  internalLinking: InternalLinkingScore;
}

class SEOAnalyzer {
  async auditTechnicalSEO(url: string): Promise<TechnicalSEOScore> {
    const checks = await Promise.all([
      this.checkMetaTags(url),
      this.validateSitemap(url),
      this.checkRobotsTxt(url),
      this.validateCanonicalUrls(url),
      this.checkHreflangTags(url)
    ]);

    return {
      metaTags: checks[0],
      sitemap: checks[1],
      robotsTxt: checks[2],
      canonicalUrls: checks[3],
      hreflangTags: checks[4],
      overallScore: this.calculateTechnicalSEOScore(checks)
    };
  }

  async checkMetaTags(url: string) {
    // 实现meta标签检查逻辑
    const response = await fetch(url);
    const html = await response.text();
    
    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
    const descriptionMatch = html.match(/<meta name="description" content="(.*?)"/i);
    const keywordsMatch = html.match(/<meta name="keywords" content="(.*?)"/i);

    return {
      title: {
        present: !!titleMatch,
        length: titleMatch ? titleMatch[1].length : 0,
        optimized: titleMatch && titleMatch[1].length >= 30 && titleMatch[1].length <= 60
      },
      description: {
        present: !!descriptionMatch,
        length: descriptionMatch ? descriptionMatch[1].length : 0,
        optimized: descriptionMatch && descriptionMatch[1].length >= 120 && descriptionMatch[1].length <= 160
      },
      keywords: {
        present: !!keywordsMatch,
        relevant: keywordsMatch ? this.analyzeKeywordRelevance(keywordsMatch[1]) : false
      }
    };
  }

  analyzeKeywordRelevance(keywords: string): boolean {
    // 实现关键词相关性分析
    const keywordList = keywords.split(',').map(k => k.trim().toLowerCase());
    // 这里可以集成Grok AI进行语义分析
    return keywordList.length > 0 && keywordList.length <= 10;
  }

  async generateStructuredData(pageContent: string) {
    // 使用Grok AI生成结构化数据
    const structuredDataPrompt = `
      根据以下页面内容，生成适合的JSON-LD结构化数据：
      ${pageContent}
      
      请生成以下类型的结构化数据：
      1. Organization (如果是公司页面)
      2. Article (如果是文章页面)
      3. WebSite (网站级别)
      4. BreadcrumbList (面包屑导航)
    `;

    // 调用Grok AI生成结构化数据
    return await this.grokAnalyzer.generateStructuredData(structuredDataPrompt);
  }
}

// optimization-advisor.js
class OptimizationAdvisor {
  constructor(grokAnalyzer) {
    this.grokAnalyzer = grokAnalyzer;
  }

  async generateOptimizationPlan(analysisResults) {
    const optimizationPrompt = `
      基于以下网站分析结果，生成详细的优化计划：
      
      设计UX评分: ${analysisResults.designUX.score}/10
      内容质量评分: ${analysisResults.contentQuality.score}/10
      技术实现评分: ${analysisResults.technicalImplementation.score}/10
      SEO基础评分: ${analysisResults.seoFoundation.score}/10
      
      请为每个低于8分的维度提供：
      1. 具体的问题识别
      2. 优先级排序（高/中/低）
      3. 详细的实施步骤
      4. 预期的改进效果
      5. 所需的技术资源
    `;

    const optimizationPlan = await this.grokAnalyzer.generateContent(optimizationPrompt);
    return this.structureOptimizationPlan(optimizationPlan);
  }

  structureOptimizationPlan(rawPlan) {
    return {
      highPriority: this.extractHighPriorityTasks(rawPlan),
      mediumPriority: this.extractMediumPriorityTasks(rawPlan),
      lowPriority: this.extractLowPriorityTasks(rawPlan),
      implementationTimeline: this.generateTimeline(rawPlan),
      resourceRequirements: this.estimateResources(rawPlan)
    };
  }
}

// components/search/SearchComponent.tsx
'use client';

import { useState, useCallback } from 'react';
import { useRouter } from 'next/navigation';
import { Search, X } from 'lucide-react';

interface SearchResult {
  id: string;
  title: string;
  slug: string;
  category: string;
  excerpt: string;
  relevanceScore: number;
}

export function SearchComponent() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState<SearchResult[]>([]);
  const [isLoading, setIsLoading] = useState(false);
  const [isOpen, setIsOpen] = useState(false);
  const router = useRouter();

  const performSearch = useCallback(async (searchQuery: string) => {
    if (searchQuery.length < 2) {
      setResults([]);
      return;
    }

    setIsLoading(true);
    try {
      const response = await fetch('/api/search', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ query: searchQuery }),
      });

      const searchResults = await response.json();
      setResults(searchResults.data || []);
    } catch (error) {
      console.error('搜索失败:', error);
      setResults([]);
    } finally {
      setIsLoading(false);
    }
  }, []);

  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    setQuery(value);
    performSearch(value);
  };

  const handleResultClick = (result: SearchResult) => {
    router.push(`/${result.category}/${result.slug}`);
    setIsOpen(false);
    setQuery('');
    setResults([]);
  };

  return (
    <div className="relative">
      <div className="relative">
        <input
          type="text"
          placeholder="搜索文章..."
          value={query}
          onChange={handleInputChange}
          onFocus={() => setIsOpen(true)}
          className="w-full px-4 py-2 pl-10 pr-10 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
        />
        <Search className="absolute left-3 top-1/2 transform -translate-y-1/2 text-gray-400 w-4 h-4" />
        {query && (
          <button
            onClick={() => {
              setQuery('');
              setResults([]);
              setIsOpen(false);
            }}
            className="absolute right-3 top-1/2 transform -translate-y-1/2 text-gray-400 hover:text-gray-600"
          >
            <X className="w-4 h-4" />
          </button>
        )}
      </div>

      {isOpen && (query.length >= 2 || results.length > 0) && (
        <div className="absolute top-full left-0 right-0 mt-2 bg-white border border-gray-200 rounded-lg shadow-lg z-50 max-h-96 overflow-y-auto">
          {isLoading && (
            <div className="p-4 text-center text-gray-500">
              正在搜索...
            </div>
          )}
          
          {!isLoading && results.length === 0 && query.length >= 2 && (
            <div className="p-4 text-center text-gray-500">
              没有找到相关内容
            </div>
          )}

          {!isLoading && results.length > 0 && (
            <div className="py-2">
              {results.map((result) => (
                <button
                  key={result.id}
                  onClick={() => handleResultClick(result)}
                  className="w-full px-4 py-3 text-left hover:bg-gray-50 focus:bg-gray-50 focus:outline-none"
                >
                  <div className="flex items-start justify-between">
                    <div className="flex-1 min-w-0">
                      <div className="text-sm font-medium text-gray-900 truncate">
                        {result.title}
                      </div>
                      <div className="text-xs text-gray-500 mt-1">
                        {result.category} • 相关度: {(result.relevanceScore * 100).toFixed(0)}%
                      </div>
                      <div className="text-xs text-gray-600 mt-1 line-clamp-2">
                        {result.excerpt}
                      </div>
                    </div>
                  </div>
                </button>
              ))}
            </div>
          )}
        </div>
      )}
    </div>
  );
}

// app/api/search/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { createClient } from '@/lib/supabase/server';

interface SearchQuery {
  query: string;
  category?: string;
  limit?: number;
}

export async function POST(request: NextRequest) {
  try {
    const body: SearchQuery = await request.json();
    const { query, category, limit = 10 } = body;

    if (!query || query.length < 2) {
      return NextResponse.json(
        { error: '搜索关键词至少需要2个字符' },
        { status: 400 }
      );
    }

    const supabase = createClient();

    // 构建搜索查询
    let searchQuery = supabase
      .from('posts')
      .select(`
        id,
        title,
        slug,
        category,
        excerpt,
        content,
        created_at
      `)
      .eq('status', 'published')
      .or(`title.ilike.%${query}%, content.ilike.%${query}%, excerpt.ilike.%${query}%`);

    if (category) {
      searchQuery = searchQuery.eq('category', category);
    }

    const { data: posts, error } = await searchQuery
      .order('created_at', { ascending: false })
      .limit(limit);

    if (error) {
      console.error('搜索查询错误:', error);
      return NextResponse.json(
        { error: '搜索服务暂时不可用' },
        { status: 500 }
      );
    }

    // 计算相关性得分
    const results = posts?.map(post => {
      const titleMatch = post.title.toLowerCase().includes(query.toLowerCase());
      const contentMatch = post.content?.toLowerCase().includes(query.toLowerCase());
      const excerptMatch = post.excerpt?.toLowerCase().includes(query.toLowerCase());

      let relevanceScore = 0;
      if (titleMatch) relevanceScore += 0.6;
      if (excerptMatch) relevanceScore += 0.3;
      if (contentMatch) relevanceScore += 0.1;

      return {
        id: post.id,
        title: post.title,
        slug: post.slug,
        category: post.category,
        excerpt: post.excerpt || post.content?.substring(0, 150) + '...',
        relevanceScore: Math.min(relevanceScore, 1)
      };
    }).sort((a, b) => b.relevanceScore - a.relevanceScore) || [];

    return NextResponse.json({
      success: true,
      data: results,
      total: results.length
    });

  } catch (error) {
    console.error('搜索API错误:', error);
    return NextResponse.json(
      { error: '内部服务器错误' },
      { status: 500 }
    );
  }
}

// components/ui/Breadcrumbs.tsx
'use client';

import Link from 'next/link';
import { ChevronRight, Home } from 'lucide-react';
import { usePathname } from 'next/navigation';

interface BreadcrumbItem {
  label: string;
  href: string;
  active?: boolean;
}

interface BreadcrumbsProps {
  items?: BreadcrumbItem[];
  className?: string;
}

export function Breadcrumbs({ items, className = '' }: BreadcrumbsProps) {
  const pathname = usePathname();
  
  // 如果没有传入items，则根据路径自动生成
  const breadcrumbItems = items || generateBreadcrumbsFromPath(pathname);

  if (breadcrumbItems.length <= 1) {
    return null; // 不显示只有首页的面包屑
  }

  return (
    <nav className={`flex items-center space-x-2 text-sm ${className}`} aria-label="面包屑导航">
      <ol className="flex items-center space-x-2">
        {breadcrumbItems.map((item, index) => (
          <li key={item.href} className="flex items-center">
            {index > 0 && (
              <ChevronRight className="mx-2 h-4 w-4 text-gray-400" />
            )}
            {item.active ? (
              <span className="text-gray-600 font-medium" aria-current="page">
                {index === 0 && <Home className="inline h-4 w-4 mr-1" />}
                {item.label}
              </span>
            ) : (
              <Link
                href={item.href}
                className="text-blue-600 hover:text-blue-800 transition-colors"
              >
                {index === 0 && <Home className="inline h-4 w-4 mr-1" />}
                {item.label}
              </Link>
            )}
          </li>
        ))}
      </ol>
    </nav>
  );
}

function generateBreadcrumbsFromPath(pathname: string): BreadcrumbItem[] {
  const segments = pathname.split('/').filter(Boolean);
  const breadcrumbs: BreadcrumbItem[] = [
    { label: '首页', href: '/' }
  ];

  let currentPath = '';
  
  segments.forEach((segment, index) => {
    currentPath += `/${segment}`;
    const isLast = index === segments.length - 1;
    
    // 处理不同的路径段
    let label = segment;
    
    // 语言前缀处理
    if (index === 0 && ['zh', 'en', 'fr'].includes(segment)) {
      label = getLanguageLabel(segment);
    }
    // 分类页面处理
    else if (['blog', 'tech', 'education', 'experiences', 'shop'].includes(segment)) {
      label = getCategoryLabel(segment);
    }
    // 文章页面处理（可以从props或context获取实际标题）
    else {
      label = decodeURIComponent(segment).replace(/-/g, ' ');
    }

    breadcrumbs.push({
      label,
      href: currentPath,
      active: isLast
    });
  });

  return breadcrumbs;
}

function getLanguageLabel(lang: string): string {
  const labels = {
    'zh': '中文',
    'en': 'English',
    'fr': 'Français'
  };
  return labels[lang as keyof typeof labels] || lang;
}

function getCategoryLabel(category: string): string {
  const labels = {
    'blog': '博客',
    'tech': '技术',
    'education': '教育',
    'experiences': '经历',
    'shop': '商店'
  };
  return labels[category as keyof typeof labels] || category;
}

// 高级版本：带有动态标题获取的面包屑
interface DynamicBreadcrumbsProps extends BreadcrumbsProps {
  postTitle?: string;
  categoryTitle?: string;
}

export function DynamicBreadcrumbs({ 
  postTitle, 
  categoryTitle, 
  className = '' 
}: DynamicBreadcrumbsProps) {
  const pathname = usePathname();
  const segments = pathname.split('/').filter(Boolean);
  
  const breadcrumbs: BreadcrumbItem[] = [
    { label: '首页', href: '/' }
  ];

  let currentPath = '';
  
  segments.forEach((segment, index) => {
    currentPath += `/${segment}`;
    const isLast = index === segments.length - 1;
    
    let label = segment;
    
    // 使用动态标题
    if (isLast && postTitle) {
      label = postTitle;
    } else if (categoryTitle && ['blog', 'tech', 'education', 'experiences', 'shop'].includes(segment)) {
      label = categoryTitle;
    } else {
      label = getCategoryLabel(segment) || getLanguageLabel(segment) || decodeURIComponent(segment);
    }

    breadcrumbs.push({
      label,
      href: currentPath,
      active: isLast
    });
  });

  return <Breadcrumbs items={breadcrumbs} className={className} />;
}

// lib/seo/structured-data.ts
interface ArticleStructuredData {
  '@context': 'https://schema.org';
  '@type': 'Article';
  headline: string;
  description: string;
  image: string[];
  datePublished: string;
  dateModified: string;
  author: {
    '@type': 'Person';
    name: string;
    url?: string;
  };
  publisher: {
    '@type': 'Organization';
    name: string;
    logo: {
      '@type': 'ImageObject';
      url: string;
    };
  };
  mainEntityOfPage: {
    '@type': 'WebPage';
    '@id': string;
  };
}

interface WebsiteStructuredData {
  '@context': 'https://schema.org';
  '@type': 'WebSite';
  name: string;
  url: string;
  potentialAction: {
    '@type': 'SearchAction';
    target: {
      '@type': 'EntryPoint';
      urlTemplate: string;
    };
    'query-input': string;
  };
}

interface BreadcrumbStructuredData {
  '@context': 'https://schema.org';
  '@type': 'BreadcrumbList';
  itemListElement: Array<{
    '@type': 'ListItem';
    position: number;
    name: string;
    item: string;
  }>;
}

export class StructuredDataGenerator {
  private baseUrl: string;

  constructor(baseUrl: string) {
    this.baseUrl = baseUrl;
  }

  generateArticleData(post: any, author: any): ArticleStructuredData {
    return {
      '@context': 'https://schema.org',
      '@type': 'Article',
      headline: post.title,
      description: post.excerpt || post.content.substring(0, 160),
      image: post.image ? [post.image] : [],
      datePublished: new Date(post.created_at).toISOString(),
      dateModified: new Date(post.updated_at || post.created_at).toISOString(),
      author: {
        '@type': 'Person',
        name: author.name || '作者',
        url: author.website || undefined
      },
      publisher: {
        '@type': 'Organization',
        name: '网站名称',
        logo: {
          '@type': 'ImageObject',
          url: `${this.baseUrl}/logo.png`
        }
      },
      mainEntityOfPage: {
        '@type': 'WebPage',
        '@id': `${this.baseUrl}${post.slug}`
      }
    };
  }

  generateWebsiteData(siteName: string): WebsiteStructuredData {
    return {
      '@context': 'https://schema.org',
      '@type': 'WebSite',
      name: siteName,
      url: this.baseUrl,
      potentialAction: {
        '@type': 'SearchAction',
        target: {
          '@type': 'EntryPoint',
          urlTemplate: `${this.baseUrl}/search?q={search_term_string}`
        },
        'query-input': 'required name=search_term_string'
      }
    };
  }

  generateBreadcrumbData(breadcrumbs: Array<{name: string; url: string}>): BreadcrumbStructuredData {
    return {
      '@context': 'https://schema.org',
      '@type': 'BreadcrumbList',
      itemListElement: breadcrumbs.map((item, index) => ({
        '@type': 'ListItem',
        position: index + 1,
        name: item.name,
        item: item.url
      }))
    };
  }

  generateOrganizationData() {
    return {
      '@context': 'https://schema.org',
      '@type': 'Organization',
      name: '网站名称',
      url: this.baseUrl,
      logo: `${this.baseUrl}/logo.png`,
      sameAs: [
        'https://twitter.com/yourhandle',
        'https://github.com/yourhandle',
        'https://linkedin.com/in/yourhandle'
      ]
    };
  }
}

// 结构化数据组件
export function StructuredDataScript({ data }: { data: any }) {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{
        __html: JSON.stringify(data, null, 2)
      }}
    />
  );
}

// lib/seo/internal-linking.ts
interface InternalLink {
  text: string;
  url: string;
  relevanceScore: number;
  contextualPhrase: string;
}

interface RelatedPost {
  id: string;
  title: string;
  slug: string;
  category: string;
  tags: string[];
  excerpt: string;
}

export class InternalLinkingEngine {
  private posts: RelatedPost[] = [];

  constructor(posts: RelatedPost[]) {
    this.posts = posts;
  }

  // 基于内容分析推荐相关链接
  async generateInternalLinks(
    currentPost: RelatedPost,
    content: string,
    maxLinks: number = 5
  ): Promise<InternalLink[]> {
    const potentialLinks: InternalLink[] = [];

    // 1. 基于标签匹配
    const tagBasedLinks = this.findTagBasedLinks(currentPost);
    
    // 2. 基于分类匹配
    const categoryBasedLinks = this.findCategoryBasedLinks(currentPost);
    
    // 3. 基于内容关键词匹配
    const keywordBasedLinks = await this.findKeywordBasedLinks(currentPost, content);

    potentialLinks.push(...tagBasedLinks, ...categoryBasedLinks, ...keywordBasedLinks);

    // 按相关性排序并限制数量
    return potentialLinks
      .sort((a, b) => b.relevanceScore - a.relevanceScore)
      .slice(0, maxLinks);
  }

  private findTagBasedLinks(currentPost: RelatedPost): InternalLink[] {
    return this.posts
      .filter(post => 
        post.id !== currentPost.id &&
        post.tags.some(tag => currentPost.tags.includes(tag))
      )
      .map(post => ({
        text: post.title,
        url: `/${post.category}/${post.slug}`,
        relevanceScore: this.calculateTagRelevance(currentPost.tags, post.tags),
        contextualPhrase: `了解更多关于${post.title}的内容`
      }));
  }

  private findCategoryBasedLinks(currentPost: RelatedPost): InternalLink[] {
    return this.posts
      .filter(post => 
        post.id !== currentPost.id &&
        post.category === currentPost.category
      )
      .map(post => ({
        text: post.title,
        url: `/${post.category}/${post.slug}`,
        relevanceScore: 0.6, // 同分类中等相关性
        contextualPhrase: `相关${this.getCategoryName(post.category)}文章：${post.title}`
      }));
  }

  private async findKeywordBasedLinks(
    currentPost: RelatedPost,
    content: string
  ): Promise<InternalLink[]> {
    // 提取关键词（这里可以集成AI服务进行更智能的分析）
    const keywords = this.extractKeywords(content);
    
    return this.posts
      .filter(post => post.id !== currentPost.id)
      .map(post => {
        const relevanceScore = this.calculateKeywordRelevance(keywords, post.title, post.excerpt);
        return {
          text: post.title,
          url: `/${post.category}/${post.slug}`,
          relevanceScore,
          contextualPhrase: `深入了解：${post.title}`
        };
      })
      .filter(link => link.relevanceScore > 0.3); // 过滤低相关性链接
  }

  private calculateTagRelevance(tags1: string[], tags2: string[]): number {
    const intersection = tags1.filter(tag => tags2.includes(tag));
    const union = [...new Set([...tags1, ...tags2])];
    return intersection.length / union.length;
  }

  private calculateKeywordRelevance(keywords: string[], title: string, excerpt: string): number {
    const text = `${title} ${excerpt}`.toLowerCase();
    const matchCount = keywords.filter(keyword => 
      text.includes(keyword.toLowerCase())
    ).length;
    return matchCount / keywords.length;
  }

  private extractKeywords(content: string): string[] {
    // 简化的关键词提取（实际项目中可使用更复杂的NLP算法）
    const words = content.toLowerCase()
      .replace(/[^\w\s\u4e00-\u9fff]/g, '') // 保留中英文字符
      .split(/\s+/)
      .filter(word => word.length > 2);

    // 统计词频
    const wordCount = words.reduce((acc, word) => {
      acc[word] = (acc[word] || 0) + 1;
      return acc;
    }, {} as Record<string, number>);

    // 返回高频词作为关键词
    return Object.entries(wordCount)
      .sort(([, a], [, b]) => b - a)
      .slice(0, 10)
      .map(([word]) => word);
  }

  private getCategoryName(category: string): string {
    const categoryNames = {
      'blog': '博客',
      'tech': '技术',
      'education': '教育',
      'experiences': '经历',
      'shop': '商店'
    };
    return categoryNames[category as keyof typeof categoryNames] || category;
  }
}

// React组件：相关文章推荐
interface RelatedPostsProps {
  currentPost: RelatedPost;
  allPosts: RelatedPost[];
  maxPosts?: number;
}

export function RelatedPosts({ currentPost, allPosts, maxPosts = 3 }: RelatedPostsProps) {
  const [relatedPosts, setRelatedPosts] = React.useState<RelatedPost[]>([]);

  React.useEffect(() => {
    const linkingEngine = new InternalLinkingEngine(allPosts);
    
    // 找到相关文章
    const related = allPosts
      .filter(post => post.id !== currentPost.id)
      .map(post => {
        const tagRelevance = linkingEngine['calculateTagRelevance'](currentPost.tags, post.tags);
        const categoryRelevance = post.category === currentPost.category ? 0.6 : 0;
        const totalRelevance = Math.max(tagRelevance, categoryRelevance);
        
        return { ...post, relevance: totalRelevance };
      })
      .sort((a, b) => b.relevance - a.relevance)
      .slice(0, maxPosts);

    setRelatedPosts(related);
  }, [currentPost, allPosts, maxPosts]);

  if (relatedPosts.length === 0) return null;

  return (
    <div className="mt-12 border-t pt-8">
      <h3 className="text-xl font-bold mb-6">相关文章推荐</h3>
      <div className="grid gap-6 md:grid-cols-2 lg:grid-cols-3">
        {relatedPosts.map((post) => (
          <Link
            key={post.id}
            href={`/${post.category}/${post.slug}`}
            className="group block p-4 border rounded-lg hover:shadow-md transition-shadow"
          >
            <h4 className="font-medium group-hover:text-blue-600 transition-colors">
              {post.title}
            </h4>
            <p className="text-sm text-gray-600 mt-2 line-clamp-3">
              {post.excerpt}
            </p>
            <div className="flex items-center justify-between mt-4 text-xs text-gray-500">
              <span>{post.category}</span>
              <span>相关度: {((post as any).relevance * 100).toFixed(0)}%</span>
            </div>
          </Link>
        ))}
      </div>
    </div>
  );
}

// lib/analysis/competitive-analysis.ts
interface CompetitorSite {
  name: string;
  url: string;
  category: string;
  targetKeywords: string[];
}

class CompetitiveAnalyzer {
  private grokAnalyzer: any;
  
  constructor(grokAnalyzer: any) {
    this.grokAnalyzer = grokAnalyzer;
  }

  async analyzeCompetitors(competitors: CompetitorSite[]) {
    const analysisResults = await Promise.all(
      competitors.map(async (competitor) => {
        const analysis = await this.grokAnalyzer.analyzeWebsite(competitor.url);
        return {
          ...competitor,
          analysis,
          timestamp: new Date().toISOString()
        };
      })
    );

    return this.generateCompetitiveBenchmark(analysisResults);
  }

  private generateCompetitiveBenchmark(results: any[]) {
    const benchmark = {
      averageScores: {
        designUX: results.reduce((sum, r) => sum + r.analysis.designUX.score, 0) / results.length,
        contentQuality: results.reduce((sum, r) => sum + r.analysis.contentQuality.score, 0) / results.length,
        technicalImplementation: results.reduce((sum, r) => sum + r.analysis.technicalImplementation.score, 0) / results.length,
        seoFoundation: results.reduce((sum, r) => sum + r.analysis.seoFoundation.score, 0) / results.length
      },
      leaders: {
        designUX: results.sort((a, b) => b.analysis.designUX.score - a.analysis.designUX.score)[0],
        contentQuality: results.sort((a, b) => b.analysis.contentQuality.score - a.analysis.contentQuality.score)[0],
        technicalImplementation: results.sort((a, b) => b.analysis.technicalImplementation.score - a.analysis.technicalImplementation.score)[0],
        seoFoundation: results.sort((a, b) => b.analysis.seoFoundation.score - a.analysis.seoFoundation.score)[0]
      },
      gapAnalysis: this.identifyOpportunities(results)
    };

    return benchmark;
  }

  private identifyOpportunities(results: any[]) {
    // 识别竞品中的优秀实践和改进机会
    const opportunities = [];
    
    // 分析设计趋势
    const highDesignScores = results.filter(r => r.analysis.designUX.score >= 8);
    if (highDesignScores.length > 0) {
      opportunities.push({
        category: 'design',
        opportunity: '学习高分网站的设计实践',
        examples: highDesignScores.map(r => r.name),
        potentialImpact: 'high'
      });
    }

    // 分析内容策略
    const highContentScores = results.filter(r => r.analysis.contentQuality.score >= 8);
    if (highContentScores.length > 0) {
      opportunities.push({
        category: 'content',
        opportunity: '优化内容策略和质量',
        examples: highContentScores.map(r => r.name),
        potentialImpact: 'high'
      });
    }

    return opportunities;
  }
}

// lib/optimization/continuous-optimizer.ts
class ContinuousOptimizer {
  private grokAnalyzer: any;
  private performanceThresholds: Record<string, number>;

  constructor(grokAnalyzer: any) {
    this.grokAnalyzer = grokAnalyzer;
    this.performanceThresholds = {
      designUX: 8,
      contentQuality: 7,
      technicalImplementation: 8,
      seoFoundation: 8
    };
  }

  async scheduleRegularAnalysis(siteUrl: string, intervalDays: number = 7) {
    // 实现定期分析逻辑
    const analysisResults = [];
    
    setInterval(async () => {
      try {
        const currentAnalysis = await this.grokAnalyzer.analyzeWebsite(siteUrl);
        analysisResults.push({
          timestamp: new Date(),
          analysis: currentAnalysis
        });

        // 检查是否需要优化
        const needsOptimization = this.checkOptimizationNeeds(currentAnalysis);
        
        if (needsOptimization.length > 0) {
          await this.generateOptimizationPlan(needsOptimization);
        }

        // 生成趋势报告
        if (analysisResults.length >= 4) { // 至少4周的数据
          await this.generateTrendReport(analysisResults.slice(-4));
        }

      } catch (error) {
        console.error('定期分析失败:', error);
      }
    }, intervalDays * 24 * 60 * 60 * 1000);
  }

  private checkOptimizationNeeds(analysis: any) {
    const needsOptimization = [];

    Object.entries(this.performanceThresholds).forEach(([metric, threshold]) => {
      if (analysis[metric]?.score < threshold) {
        needsOptimization.push({
          metric,
          currentScore: analysis[metric].score,
          threshold,
          gap: threshold - analysis[metric].score
        });
      }
    });

    return needsOptimization;
  }

  private async generateOptimizationPlan(optimizationNeeds: any[]) {
    const prioritizedTasks = optimizationNeeds.sort((a, b) => b.gap - a.gap);
    
    const optimizationPlan = {
      urgentTasks: prioritizedTasks.filter(task => task.gap >= 2),
      importantTasks: prioritizedTasks.filter(task => task.gap >= 1 && task.gap < 2),
      minorTasks: prioritizedTasks.filter(task => task.gap < 1),
      estimatedTimeToCompletion: this.estimateCompletionTime(prioritizedTasks)
    };

    // 发送通知或记录到数据库
    await this.notifyOptimizationTeam(optimizationPlan);
    
    return optimizationPlan;
  }

  private async generateTrendReport(recentAnalyses: any[]) {
    const trends = {
      improving: [],
      declining: [],
      stable: []
    };

    const metrics = ['designUX', 'contentQuality', 'technicalImplementation', 'seoFoundation'];
    
    metrics.forEach(metric => {
      const scores = recentAnalyses.map(a => a.analysis[metric]?.score || 0);
      const trend = this.calculateTrend(scores);
      
      if (trend > 0.5) {
        trends.improving.push({ metric, trend });
      } else if (trend < -0.5) {
        trends.declining.push({ metric, trend });
      } else {
        trends.stable.push({ metric, trend });
      }
    });

    return trends;
  }

  private calculateTrend(scores: number[]): number {
    if (scores.length < 2) return 0;
    
    // 简单线性趋势计算
    const n = scores.length;
    const sumX = (n * (n + 1)) / 2;
    const sumY = scores.reduce((sum, score) => sum + score, 0);
    const sumXY = scores.reduce((sum, score, index) => sum + (index + 1) * score, 0);
    const sumX2 = (n * (n + 1) * (2 * n + 1)) / 6;
    
    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
    return slope;
  }

  private estimateCompletionTime(tasks: any[]): string {
    const baseHours = {
      designUX: 16,
      contentQuality: 12,
      technicalImplementation: 20,
      seoFoundation: 8
    };

    const totalHours = tasks.reduce((sum, task) => {
      return sum + (baseHours[task.metric as keyof typeof baseHours] || 8) * task.gap;
    }, 0);

    const days = Math.ceil(totalHours / 8);
    return days > 1 ? `约${days}个工作日` : '1个工作日内';
  }

  private async notifyOptimizationTeam(plan: any) {
    // 实现团队通知逻辑（邮件、Slack等）
    console.log('优化计划已生成:', plan);
  }
}