import { seoServiceBySlug } from "@/data/seo/services";
import { seoSegmentBySlug } from "@/data/seo/segments";
import { seoCityBySlug } from "@/data/seo/cities";
import { seoStateBySlug } from "@/data/seo/states";
import type { SeoPageContext, SeoPageKind } from "./types";

const SERVICE_SLUGS = new Set(Object.keys(seoServiceBySlug));
const SEGMENT_SLUGS = new Set(Object.keys(seoSegmentBySlug));
const CITY_SLUGS = new Set(Object.keys(seoCityBySlug));
const STATE_SLUGS = new Set(Object.keys(seoStateBySlug));

export function buildServiceCitySlug(serviceSlug: string, citySlug: string): string {
  return `${serviceSlug}-em-${citySlug}`;
}

export function buildServiceStateSlug(serviceSlug: string, stateSlug: string): string {
  const state = seoStateBySlug[stateSlug];
  const prep = state?.preposition === "no" ? "no" : "em";
  return `${serviceSlug}-${prep}-${stateSlug}`;
}

export function buildSegmentSlug(segmentSlug: string): string {
  return `app-para-${segmentSlug}`;
}

export function buildSegmentCitySlug(segmentSlug: string, citySlug: string): string {
  return `app-para-${segmentSlug}-em-${citySlug}`;
}

export function buildServiceSegmentSlug(serviceSlug: string, segmentSlug: string): string {
  return `${serviceSlug}-para-${segmentSlug}`;
}

export function buildServiceSegmentCitySlug(
  serviceSlug: string,
  segmentSlug: string,
  citySlug: string,
): string {
  return `${serviceSlug}-para-${segmentSlug}-em-${citySlug}`;
}

export function buildServiceSegmentStateSlug(
  serviceSlug: string,
  segmentSlug: string,
  stateSlug: string,
): string {
  const state = seoStateBySlug[stateSlug];
  const prep = state?.preposition === "no" ? "no" : "em";
  return `${serviceSlug}-para-${segmentSlug}-${prep}-${stateSlug}`;
}

export function buildAppRoutePath(
  kind: SeoPageKind,
  a: string,
  b?: string,
): string {
  if (kind === "service-city" || kind === "service-state") {
    return `/app/${a}/${b ?? ""}`;
  }
  if (kind === "segment") return `/app/segmento/${a}`;
  if (kind === "segment-city" || kind === "segment-state") {
    return `/app/segmento/${a}/${b ?? ""}`;
  }
  if (kind === "service-segment") return `/app/solucao/${a}/${b ?? ""}`;
  if (kind === "service-segment-city" || kind === "service-segment-state") {
    return `/app/solucao/${a}/${b ?? ""}`;
  }
  return `/app/${a}`;
}

function resolveLocationSlug(
  slug: string,
): { city?: string; state?: string } | null {
  if (CITY_SLUGS.has(slug)) return { city: slug };
  if (STATE_SLUGS.has(slug)) return { state: slug };
  return null;
}

/** Resolve flat SEO slug (ex: criacao-de-app-em-belo-horizonte) */
export function resolveFlatSlug(slug: string): SeoPageContext | null {
  if (slug.startsWith("app-para-")) {
    const rest = slug.slice("app-para-".length);
    const emIdx = rest.lastIndexOf("-em-");
    if (emIdx > 0) {
      const segmentSlug = rest.slice(0, emIdx);
      const citySlug = rest.slice(emIdx + 4);
      if (SEGMENT_SLUGS.has(segmentSlug) && CITY_SLUGS.has(citySlug)) {
        return {
          kind: "segment-city",
          slug,
          segment: seoSegmentBySlug[segmentSlug],
          city: seoCityBySlug[citySlug],
        };
      }
    }
    if (SEGMENT_SLUGS.has(rest)) {
      return {
        kind: "segment",
        slug,
        segment: seoSegmentBySlug[rest],
      };
    }
  }

  for (const serviceSlug of SERVICE_SLUGS) {
    const paraPrefix = `${serviceSlug}-para-`;
    if (slug.startsWith(paraPrefix)) {
      const rest = slug.slice(paraPrefix.length);
      const emIdx = rest.lastIndexOf("-em-");
      const noIdx = rest.lastIndexOf("-no-");
      const naIdx = rest.lastIndexOf("-na-");
      const locIdx = Math.max(emIdx, noIdx, naIdx);

      if (locIdx > 0) {
        const segmentSlug = rest.slice(0, locIdx);
        const prepLen = emIdx === locIdx ? 4 : 4;
        const locSlug = rest.slice(locIdx + prepLen);
        if (!SEGMENT_SLUGS.has(segmentSlug)) continue;

        const loc = resolveLocationSlug(locSlug);
        if (loc?.city) {
          return {
            kind: "service-segment-city",
            slug,
            service: seoServiceBySlug[serviceSlug],
            segment: seoSegmentBySlug[segmentSlug],
            city: seoCityBySlug[loc.city],
          };
        }
        if (loc?.state) {
          return {
            kind: "service-segment-state",
            slug,
            service: seoServiceBySlug[serviceSlug],
            segment: seoSegmentBySlug[segmentSlug],
            state: seoStateBySlug[loc.state],
          };
        }
      }

      if (SEGMENT_SLUGS.has(rest)) {
        return {
          kind: "service-segment",
          slug,
          service: seoServiceBySlug[serviceSlug],
          segment: seoSegmentBySlug[rest],
        };
      }
    }

    for (const prep of ["-em-", "-no-", "-na-"] as const) {
      const prefix = `${serviceSlug}${prep}`;
      if (!slug.startsWith(prefix)) continue;
      const locSlug = slug.slice(prefix.length);
      const loc = resolveLocationSlug(locSlug);
      if (loc?.city) {
        return {
          kind: "service-city",
          slug,
          service: seoServiceBySlug[serviceSlug],
          city: seoCityBySlug[loc.city],
        };
      }
      if (loc?.state) {
        return {
          kind: "service-state",
          slug,
          service: seoServiceBySlug[serviceSlug],
          state: seoStateBySlug[loc.state],
        };
      }
    }
  }

  return null;
}

export function resolveAppRouteParams(
  first: string,
  second?: string,
): SeoPageContext | null {
  if (first === "segmento") {
    if (!second) return null;
    if (CITY_SLUGS.has(second)) {
      return null;
    }
    if (SEGMENT_SLUGS.has(second)) {
      return {
        kind: "segment",
        slug: buildSegmentSlug(second),
        segment: seoSegmentBySlug[second],
      };
    }
    if (SEGMENT_SLUGS.has(first) && CITY_SLUGS.has(second)) {
      return {
        kind: "segment-city",
        slug: buildSegmentCitySlug(first, second),
        segment: seoSegmentBySlug[first],
        city: seoCityBySlug[second],
      };
    }
    return null;
  }

  if (SERVICE_SLUGS.has(first)) {
    if (!second) return null;
    if (CITY_SLUGS.has(second)) {
      return {
        kind: "service-city",
        slug: buildServiceCitySlug(first, second),
        service: seoServiceBySlug[first],
        city: seoCityBySlug[second],
      };
    }
    if (STATE_SLUGS.has(second)) {
      return {
        kind: "service-state",
        slug: buildServiceStateSlug(first, second),
        service: seoServiceBySlug[first],
        state: seoStateBySlug[second],
      };
    }
    if (SEGMENT_SLUGS.has(second)) {
      return {
        kind: "service-segment",
        slug: buildServiceSegmentSlug(first, second),
        service: seoServiceBySlug[first],
        segment: seoSegmentBySlug[second],
      };
    }
  }

  if (SEGMENT_SLUGS.has(first) && second) {
    if (CITY_SLUGS.has(second)) {
      return {
        kind: "segment-city",
        slug: buildSegmentCitySlug(first, second),
        segment: seoSegmentBySlug[first],
        city: seoCityBySlug[second],
      };
    }
    if (STATE_SLUGS.has(second)) {
      return {
        kind: "segment-state",
        slug: `app-para-${first}-em-${second}`,
        segment: seoSegmentBySlug[first],
        state: seoStateBySlug[second],
      };
    }
  }

  return null;
}

export function resolveSegmentRoute(
  segmentSlug: string,
  localSlug?: string,
): SeoPageContext | null {
  if (!SEGMENT_SLUGS.has(segmentSlug)) return null;
  if (!localSlug) {
    return {
      kind: "segment",
      slug: buildSegmentSlug(segmentSlug),
      segment: seoSegmentBySlug[segmentSlug],
    };
  }
  if (CITY_SLUGS.has(localSlug)) {
    return {
      kind: "segment-city",
      slug: buildSegmentCitySlug(segmentSlug, localSlug),
      segment: seoSegmentBySlug[segmentSlug],
      city: seoCityBySlug[localSlug],
    };
  }
  if (STATE_SLUGS.has(localSlug)) {
    return {
      kind: "segment-state",
      slug: `app-para-${segmentSlug}-em-${localSlug}`,
      segment: seoSegmentBySlug[segmentSlug],
      state: seoStateBySlug[localSlug],
    };
  }
  return null;
}

export function resolveServiceRoute(
  serviceSlug: string,
  localOrSegment?: string,
  citySlug?: string,
): SeoPageContext | null {
  if (!SERVICE_SLUGS.has(serviceSlug)) return null;
  if (!localOrSegment) return null;

  if (citySlug && SEGMENT_SLUGS.has(localOrSegment) && CITY_SLUGS.has(citySlug)) {
    return {
      kind: "service-segment-city",
      slug: buildServiceSegmentCitySlug(serviceSlug, localOrSegment, citySlug),
      service: seoServiceBySlug[serviceSlug],
      segment: seoSegmentBySlug[localOrSegment],
      city: seoCityBySlug[citySlug],
    };
  }

  if (CITY_SLUGS.has(localOrSegment)) {
    return {
      kind: "service-city",
      slug: buildServiceCitySlug(serviceSlug, localOrSegment),
      service: seoServiceBySlug[serviceSlug],
      city: seoCityBySlug[localOrSegment],
    };
  }
  if (STATE_SLUGS.has(localOrSegment)) {
    return {
      kind: "service-state",
      slug: buildServiceStateSlug(serviceSlug, localOrSegment),
      service: seoServiceBySlug[serviceSlug],
      state: seoStateBySlug[localOrSegment],
    };
  }
  if (SEGMENT_SLUGS.has(localOrSegment)) {
    return {
      kind: "service-segment",
      slug: buildServiceSegmentSlug(serviceSlug, localOrSegment),
      service: seoServiceBySlug[serviceSlug],
      segment: seoSegmentBySlug[localOrSegment],
    };
  }
  return null;
}

export function resolveSolutionRoute(
  serviceSlug: string,
  segmentSlug: string,
  localSlug?: string,
): SeoPageContext | null {
  if (!SERVICE_SLUGS.has(serviceSlug) || !SEGMENT_SLUGS.has(segmentSlug)) return null;
  if (!localSlug) {
    return {
      kind: "service-segment",
      slug: buildServiceSegmentSlug(serviceSlug, segmentSlug),
      service: seoServiceBySlug[serviceSlug],
      segment: seoSegmentBySlug[segmentSlug],
    };
  }
  if (CITY_SLUGS.has(localSlug)) {
    return {
      kind: "service-segment-city",
      slug: buildServiceSegmentCitySlug(serviceSlug, segmentSlug, localSlug),
      service: seoServiceBySlug[serviceSlug],
      segment: seoSegmentBySlug[segmentSlug],
      city: seoCityBySlug[localSlug],
    };
  }
  if (STATE_SLUGS.has(localSlug)) {
    return {
      kind: "service-segment-state",
      slug: buildServiceSegmentStateSlug(serviceSlug, segmentSlug, localSlug),
      service: seoServiceBySlug[serviceSlug],
      segment: seoSegmentBySlug[segmentSlug],
      state: seoStateBySlug[localSlug],
    };
  }
  return null;
}