/**
 * Internal Link Configuration for SEO Tool
 * Defines rules for internal link optimization and analysis
 */

import { PageInfo } from "./seo-utils"

/**
 * Priority link configuration
 * These links will be prioritized when optimizing internal links
 */
export interface PriorityLink {
  targetRoute: string
  keywords: string[]
  maxLinks: number
  anchorTexts: string[]
  priority: number // 1-10, where 10 is highest priority
}

/**
 * Keyword to page mapping
 * Auto-magically link specific keywords to target pages
 */
export interface KeywordMapping {
  keyword: string
  targetRoute: string
  variations?: string[]
  useNaturalAnchorText?: boolean
}

/**
 * Page-specific configuration
 */
export interface PageConfig {
  excludeSections?: string[]
  maxLinksPerPage?: number
  minWordsBetweenLinks?: number
  preferredAnchorText?: string
}

/**
 * Link density configuration
 */
export interface LinkDensityConfig {
  maxLinksPerPage: number
  minWordsBetweenLinks: number
  maxLinksPerParagraph: number
  maxPercentagePerPage: number
}

/**
 * SEO scoring weights
 */
export interface ScoringWeights {
  title: number
  description: number
  internalLinks: number
  contentLength: number
  keywordOptimization: number
  structure: number
  imageOptimization: number
}

/**
 * Master configuration
 */
export interface InternalLinkConfig {
  // General settings
  businessName: string
  websiteUrl: string

  // Priority links
  priorityLinks: PriorityLink[]

  // Keyword mappings
  keywordMappings: KeywordMapping[]

  // Page-specific configurations
  pageConfigs: Record<string, PageConfig>

  // Link density settings
  linkDensity: LinkDensityConfig

  // SEO scoring weights
  scoringWeights: ScoringWeights

  // Excluded pages
  excludedPages: string[]

  // Excluded sections within pages
  excludedSections: string[]

  // Anchor text preferences
  anchorTextPreferences: {
    preferPageTitle: boolean
    useNaturalLanguage: boolean
    avoidGenericText: string[]
  }
}

/**
 * Default configuration
 */
export const defaultConfig: InternalLinkConfig = {
  businessName: "Rocky Mountain Vending",
  websiteUrl: "https://rockymountainvending.com",

  priorityLinks: [
    {
      targetRoute: "services/repairs",
      keywords: [
        "repair",
        "repairs",
        "fix",
        "broken",
        "maintenance",
        "service",
        "fixing",
      ],
      maxLinks: 3,
      anchorTexts: [
        "vending machine repairs",
        "repair services",
        "vending machine repair",
        "fixing",
      ],
      priority: 10,
    },
    {
      targetRoute: "vending-machines/machines-for-sale",
      keywords: [
        "buy",
        "purchase",
        "sale",
        "for sale",
        "machine",
        "equipment",
        "acquire",
      ],
      maxLinks: 2,
      anchorTexts: [
        "vending machines for sale",
        "buy vending machines",
        "vending machine sales",
        "purchase",
      ],
      priority: 9,
    },
    {
      targetRoute: "vending-machines/machines-we-use",
      keywords: ["machine", "equipment", "vending", "use", "utilize", "employ"],
      maxLinks: 2,
      anchorTexts: [
        "vending machines we use",
        "our machines",
        "vending equipment",
        "vending systems",
      ],
      priority: 8,
    },
    {
      targetRoute: "about-us",
      keywords: ["about", "company", "us", "we", "our", "team", "business"],
      maxLinks: 1,
      anchorTexts: ["about us", "about Rocky Mountain Vending", "our company"],
      priority: 7,
    },
    {
      targetRoute: "contact-us",
      keywords: [
        "contact",
        "reach",
        "call",
        "phone",
        "email",
        "get in touch",
        "reach out",
      ],
      maxLinks: 2,
      anchorTexts: ["contact us", "get in touch", "reach out", "call us"],
      priority: 8,
    },
    {
      targetRoute: "food-and-beverage/healthy-options",
      keywords: [
        "healthy",
        "wellness",
        "nutrition",
        "snack",
        "beverage",
        "options",
      ],
      maxLinks: 2,
      anchorTexts: [
        "healthy vending",
        "healthy options",
        "wellness vending",
        "healthy snacks",
      ],
      priority: 7,
    },
    {
      targetRoute: "food-and-beverage/traditional-options",
      keywords: [
        "traditional",
        "classic",
        "standard",
        "conventional",
        "regular",
      ],
      maxLinks: 2,
      anchorTexts: [
        "traditional vending",
        "classic vending",
        "standard options",
      ],
      priority: 6,
    },
    {
      targetRoute: "services/parts",
      keywords: [
        "parts",
        "component",
        "replacement",
        "spare",
        "accessories",
        "supplies",
      ],
      maxLinks: 2,
      anchorTexts: [
        "vending machine parts",
        "parts and support",
        "replacement parts",
        "spare parts",
      ],
      priority: 7,
    },
  ],

  keywordMappings: [
    {
      keyword: "warehouse",
      targetRoute: "warehouses",
      variations: ["warehouses"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "auto repair",
      targetRoute: "auto-repair",
      variations: ["auto-repair", "automotive repair"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "gym",
      targetRoute: "gyms",
      variations: ["gyms", "fitness center"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "community center",
      targetRoute: "community-centers",
      variations: ["community centers", "community facility"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "dance studio",
      targetRoute: "dance-studios",
      variations: ["dance studios", "dance facility"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "car wash",
      targetRoute: "car-washes",
      variations: ["car washes", "car washing"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "suppliers",
      targetRoute: "food-and-beverage/suppliers",
      variations: ["supplier", "wholesale", "distributor"],
      useNaturalAnchorText: true,
    },
    {
      keyword: "faq",
      targetRoute: "about/faqs",
      variations: ["faqs", "frequently asked", "questions"],
      useNaturalAnchorText: false,
    },
    {
      keyword: "manuals",
      targetRoute: "manuals",
      variations: ["manual", "guide", "documentation"],
      useNaturalAnchorText: true,
    },
  ],

  pageConfigs: {
    "": {
      // Home page
      maxLinksPerPage: 8,
      minWordsBetweenLinks: 100,
    },
    "about-us": {
      maxLinksPerPage: 3,
      minWordsBetweenLinks: 150,
    },
    "contact-us": {
      maxLinksPerPage: 2,
      minWordsBetweenLinks: 200,
    },
    services: {
      maxLinksPerPage: 6,
      minWordsBetweenLinks: 80,
    },
    "vending-machines": {
      maxLinksPerPage: 5,
      minWordsBetweenLinks: 90,
    },
    manuals: {
      maxLinksPerPage: 4,
      minWordsBetweenLinks: 120,
    },
  },

  linkDensity: {
    maxLinksPerPage: 10,
    minWordsBetweenLinks: 50,
    maxLinksPerParagraph: 2,
    maxPercentagePerPage: 3,
  },

  scoringWeights: {
    title: 0.2,
    description: 0.15,
    internalLinks: 0.25,
    contentLength: 0.15,
    keywordOptimization: 0.15,
    structure: 0.05,
    imageOptimization: 0.05,
  },

  excludedPages: ["api", "robots", "sitemap"],

  excludedSections: ["header", "footer", "navigation", "sidebar", "menu"],

  anchorTextPreferences: {
    preferPageTitle: true,
    useNaturalLanguage: true,
    avoidGenericText: [
      "click here",
      "read more",
      "link",
      "learn more",
      "visit",
    ],
  },
}

/**
 * Get configuration for a specific page
 */
export function getPageConfig(
  route: string,
  config: InternalLinkConfig = defaultConfig
): PageConfig {
  // Check exact match first
  if (config.pageConfigs[route]) {
    return config.pageConfigs[route]
  }

  // Check partial matches (e.g., services/*)
  for (const [key, pageConfig] of Object.entries(config.pageConfigs)) {
    if (key !== "" && route.startsWith(key)) {
      return pageConfig
    }
  }

  // Return default config
  return {
    maxLinksPerPage: config.linkDensity.maxLinksPerPage,
    minWordsBetweenLinks: config.linkDensity.minWordsBetweenLinks,
  }
}

/**
 * Get all keywords that should be linked to a target page
 */
export function getKeywordsForTarget(
  targetRoute: string,
  config: InternalLinkConfig = defaultConfig
): string[] {
  const keywords: string[] = []

  // Add priority link keywords
  const priorityLink = config.priorityLinks.find(
    (pl) => pl.targetRoute === targetRoute
  )
  if (priorityLink) {
    keywords.push(...priorityLink.keywords)
  }

  // Add keyword mapping keywords
  for (const mapping of config.keywordMappings) {
    if (mapping.targetRoute === targetRoute) {
      keywords.push(mapping.keyword)
      if (mapping.variations) {
        keywords.push(...mapping.variations)
      }
    }
  }

  // Remove duplicates
  return [...new Set(keywords)]
}

/**
 * Get anchor text options for a target page
 */
export function getAnchorTexts(
  targetRoute: string,
  config: InternalLinkConfig = defaultConfig
): string[] {
  // Get from priority links
  const priorityLink = config.priorityLinks.find(
    (pl) => pl.targetRoute === targetRoute
  )
  if (priorityLink && priorityLink.anchorTexts.length > 0) {
    return priorityLink.anchorTexts
  }

  // Default to page title
  return [targetRoute.split("/").pop() || targetRoute]
}

/**
 * Check if a route should be excluded from linking
 */
export function isExcludedRoute(
  route: string,
  config: InternalLinkConfig = defaultConfig
): boolean {
  return config.excludedPages.some(
    (excluded) => route === excluded || route.startsWith(excluded + "/")
  )
}

/**
 * Calculate maximum links allowed for a page
 */
export function getMaxLinksForPage(
  route: string,
  config: InternalLinkConfig = defaultConfig
): number {
  const pageConfig = getPageConfig(route, config)
  return pageConfig.maxLinksPerPage || config.linkDensity.maxLinksPerPage
}

/**
 * Calculate minimum words between links
 */
export function getMinWordsBetweenLinks(
  route: string,
  config: InternalLinkConfig = defaultConfig
): number {
  const pageConfig = getPageConfig(route, config)
  return (
    pageConfig.minWordsBetweenLinks || config.linkDensity.minWordsBetweenLinks
  )
}

/**
 * SEO scoring function
 */
export function calculatePageScore(
  route: string,
  content: string,
  internalLinks: { to: string; text: string }[],
  config: InternalLinkConfig = defaultConfig
): number {
  const weights = config.scoringWeights
  let score = 0

  // Title score (20%)
  const hasTitle = content.match(/title:/i) || content.match(/Head>/i)
  score += hasTitle ? weights.title : 0

  // Description score (15%)
  const hasDescription =
    content.match(/description:/i) || content.match(/Head>/i)
  score += hasDescription ? weights.description : 0

  // Internal links score (25%)
  const maxLinks = getMaxLinksForPage(route, config)
  const linkScore =
    Math.min(internalLinks.length / maxLinks, 1) * weights.internalLinks
  score += linkScore

  // Content length score (15%)
  const wordCount = content.split(/\s+/).length
  const contentScore = Math.min(wordCount / 500, 1) * weights.contentLength
  score += contentScore

  // Keyword optimization score (15%)
  const keywordsFound = findKeywordsInContent(content, config).length
  const keywordScore =
    Math.min(keywordsFound / 10, 1) * weights.keywordOptimization
  score += keywordScore

  // Structure score (5%)
  const hasGoodStructure = content.match(/<h[1-6]>/i) && content.match(/<p>/i)
  score += hasGoodStructure ? weights.structure : 0

  // Image optimization score (5%)
  const imageCount = (content.match(/<img[^>]*>/gi) || []).length
  const imageScore = Math.min(imageCount / 3, 1) * weights.imageOptimization
  score += imageScore

  return Math.round(score * 100) / 100
}

/**
 * Find keywords in content for SEO analysis
 */
export function findKeywordsInContent(
  content: string,
  config: InternalLinkConfig = defaultConfig
): string[] {
  const keywords: string[] = []
  const allKeywords = [
    ...config.priorityLinks.flatMap((pl) => pl.keywords),
    ...config.keywordMappings.map((km) => km.keyword),
    ...config.keywordMappings.flatMap((km) => km.variations || []),
  ]

  const contentLower = content.toLowerCase()

  for (const keyword of allKeywords) {
    if (contentLower.includes(keyword.toLowerCase())) {
      keywords.push(keyword)
    }
  }

  return [...new Set(keywords)]
}