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

/**
 * Priority link configuration
 * These links will be prioritized when optimizing internal links
 */
export class PriorityLink {
  constructor(targetRoute, keywords, maxLinks, anchorTexts, priority) {
    this.targetRoute = targetRoute;
    this.keywords = keywords;
    this.maxLinks = maxLinks;
    this.anchorTexts = anchorTexts;
    this.priority = priority;
  }
}

/**
 * Keyword to page mapping
 * Auto-magically link specific keywords to target pages
 */
export class KeywordMapping {
  constructor(keyword, targetRoute, variations, useNaturalAnchorText) {
    this.keyword = keyword;
    this.targetRoute = targetRoute;
    this.variations = variations || [];
    this.useNaturalAnchorText = useNaturalAnchorText || false;
  }
}

/**
 * Page-specific configuration
 */
export class PageConfig {
  constructor(excludeSections, maxLinksPerPage, minWordsBetweenLinks, preferredAnchorText) {
    this.excludeSections = excludeSections || [];
    this.maxLinksPerPage = maxLinksPerPage;
    this.minWordsBetweenLinks = minWordsBetweenLinks;
    this.preferredAnchorText = preferredAnchorText;
  }
}

/**
 * Link density configuration
 */
export class LinkDensityConfig {
  constructor(maxLinksPerPage, minWordsBetweenLinks, maxLinksPerParagraph, maxPercentagePerPage) {
    this.maxLinksPerPage = maxLinksPerPage;
    this.minWordsBetweenLinks = minWordsBetweenLinks;
    this.maxLinksPerParagraph = maxLinksPerParagraph;
    this.maxPercentagePerPage = maxPercentagePerPage;
  }
}

/**
 * SEO scoring weights
 */
export class ScoringWeights {
  constructor(title, description, internalLinks, contentLength, keywordOptimization, structure, imageOptimization) {
    this.title = title;
    this.description = description;
    this.internalLinks = internalLinks;
    this.contentLength = contentLength;
    this.keywordOptimization = keywordOptimization;
    this.structure = structure;
    this.imageOptimization = imageOptimization;
  }
}

/**
 * Master configuration
 */
export class InternalLinkConfig {
  constructor(businessName, websiteUrl, priorityLinks, keywordMappings, pageConfigs, linkDensity, scoringWeights, excludedPages, excludedSections, anchorTextPreferences) {
    this.businessName = businessName;
    this.websiteUrl = websiteUrl;
    this.priorityLinks = priorityLinks;
    this.keywordMappings = keywordMappings;
    this.pageConfigs = pageConfigs;
    this.linkDensity = linkDensity;
    this.scoringWeights = scoringWeights;
    this.excludedPages = excludedPages;
    this.excludedSections = excludedSections;
    this.anchorTextPreferences = anchorTextPreferences;
  }
}

/**
 * Default configuration
 */
export const defaultConfig = new InternalLinkConfig(
  "Rocky Mountain Vending",
  "https://rockymountainvending.com",
  [
    new PriorityLink("services/repairs", ["repair", "repairs", "fix", "broken", "maintenance", "service", "fixing"], 3, ["vending machine repairs", "repair services", "vending machine repair", "fixing"], 10),
    new PriorityLink("vending-machines/machines-for-sale", ["buy", "purchase", "sale", "for sale", "machine", "equipment", "acquire"], 2, ["vending machines for sale", "buy vending machines", "vending machine sales", "purchase"], 9),
    new PriorityLink("vending-machines/machines-we-use", ["machine", "equipment", "vending", "use", "utilize", "employ"], 2, ["vending machines we use", "our machines", "vending equipment", "vending systems"], 8),
    new PriorityLink("about-us", ["about", "company", "us", "we", "our", "team", "business"], 1, ["about us", "about Rocky Mountain Vending", "our company"], 7),
    new PriorityLink("contact-us", ["contact", "reach", "call", "phone", "email", "get in touch", "reach out"], 2, ["contact us", "get in touch", "reach out", "call us"], 8),
    new PriorityLink("food-and-beverage/healthy-options", ["healthy", "wellness", "nutrition", "snack", "beverage", "options"], 2, ["healthy vending", "healthy options", "wellness vending", "healthy snacks"], 7),
    new PriorityLink("food-and-beverage/traditional-options", ["traditional", "classic", "standard", "conventional", "regular"], 2, ["traditional vending", "classic vending", "standard options"], 6),
    new PriorityLink("services/parts", ["parts", "component", "replacement", "spare", "accessories", "supplies"], 2, ["vending machine parts", "parts and support", "replacement parts", "spare parts"], 7)
  ],
  [
    new KeywordMapping("warehouse", "warehouses", ["warehouses"], true),
    new KeywordMapping("auto repair", "auto-repair", ["auto-repair", "automotive repair"], true),
    new KeywordMapping("gym", "gyms", ["gyms", "fitness center"], true),
    new KeywordMapping("community center", "community-centers", ["community centers", "community facility"], true),
    new KeywordMapping("dance studio", "dance-studios", ["dance studios", "dance facility"], true),
    new KeywordMapping("car wash", "car-washes", ["car washes", "car washing"], true),
    new KeywordMapping("suppliers", "food-and-beverage/suppliers", ["supplier", "wholesale", "distributor"], true),
    new KeywordMapping("faq", "about/faqs", ["faqs", "frequently asked", "questions"], false),
    new KeywordMapping("manuals", "manuals", ["manual", "guide", "documentation"], true)
  ],
  {
    "": new PageConfig(null, 8, 100),
    "about-us": new PageConfig(null, 3, 150),
    "contact-us": new PageConfig(null, 2, 200),
    "services": new PageConfig(null, 6, 80),
    "vending-machines": new PageConfig(null, 5, 90),
    "manuals": new PageConfig(null, 4, 120)
  },
  new LinkDensityConfig(10, 50, 2, 3),
  new ScoringWeights(0.2, 0.15, 0.25, 0.15, 0.15, 0.05, 0.05),
  ["api", "robots", "sitemap"],
  ["header", "footer", "navigation", "sidebar", "menu"],
  {
    preferPageTitle: true,
    useNaturalLanguage: true,
    avoidGenericText: ["click here", "read more", "link", "learn more", "visit"]
  }
);

/**
 * Get configuration for a specific page
 */
export function getPageConfig(route, config = defaultConfig) {
  // 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 new PageConfig(null, config.linkDensity.maxLinksPerPage, config.linkDensity.minWordsBetweenLinks);
}

/**
 * Get all keywords that should be linked to a target page
 */
export function getKeywordsForTarget(targetRoute, config = defaultConfig) {
  const keywords = [];
  
  // 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, config = defaultConfig) {
  // 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, config = defaultConfig) {
  return config.excludedPages.some(excluded => 
    route === excluded || route.startsWith(excluded + '/')
  );
}

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

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

/**
 * SEO scoring function
 */
export function calculatePageScore(route, content, internalLinks, config = defaultConfig) {
  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, config = defaultConfig) {
  const keywords = [];
  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)];
}