<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "SEO Rehberi"
}
</script>

<article itemscope itemtype="https://schema.org/Article">
  <h1 itemprop="headline">SEO Rehberi</h1>
</article>

<article vocab="https://schema.org/" typeof="Article">
  <h1 property="headline">SEO Rehberi</h1>
</article>

// components/JsonLd.tsx
interface JsonLdProps {
  data: Record<string, unknown>;
}

export function JsonLd({ data }: JsonLdProps) {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{
        __html: JSON.stringify(data)
      }}
    />
  );
}

// lib/schema.ts
const SITE_URL = 'https://beydemir.dev';

interface Author {
  name: string;
  url?: string;
}

interface ArticleSchemaInput {
  title: string;
  description: string;
  slug: string;
  date: string;
  author: Author;
  image: string;
  tags?: string[];
}

export function generateArticleSchema(input: ArticleSchemaInput) {
  return {
    '@context': 'https://schema.org',
    '@type': 'Article',
    headline: input.title,
    description: input.description,
    image: input.image,
    datePublished: input.date,
    dateModified: input.date,
    author: {
      '@type': 'Person',
      name: input.author.name,
      url: input.author.url || SITE_URL,
    },
    publisher: {
      '@type': 'Organization',
      name: 'Beydemir.dev',
      url: SITE_URL,
      logo: {
        '@type': 'ImageObject',
        url: `${SITE_URL}/logo.png`,
      },
    },
    mainEntityOfPage: {
      '@type': 'WebPage',
      '@id': `${SITE_URL}/blog/${input.slug}`,
    },
    keywords: input.tags?.join(', '),
  };
}

// app/blog/[slug]/page.tsx
import { JsonLd } from '@/components/JsonLd';
import { generateArticleSchema } from '@/lib/schema';
import { getPostBySlug } from '@/lib/mdx';

export default async function BlogPost({ params }: Props) {
  const post = await getPostBySlug(params.slug);

  const articleSchema = generateArticleSchema({
    title: post.title,
    description: post.excerpt,
    slug: post.slug,
    date: post.date,
    author: {
      name: post.author,
      url: 'https://beydemir.dev',
    },
    image: post.imageUrl,
    tags: post.tags,
  });

  return (
    <>
      <JsonLd data={articleSchema} />
      <article>
        <h1>{post.title}</h1>
        {/* İçerik */}
      </article>
    </>
  );
}

// lib/schema.ts
interface FAQItem {
  question: string;
  answer: string;
}

export function generateFAQSchema(items: FAQItem[]) {
  return {
    '@context': 'https://schema.org',
    '@type': 'FAQPage',
    mainEntity: items.map(item => ({
      '@type': 'Question',
      name: item.question,
      acceptedAnswer: {
        '@type': 'Answer',
        text: item.answer,
      },
    })),
  };
}

// lib/faq-extractor.ts
interface FAQItem {
  question: string;
  answer: string;
}

export function extractFAQFromContent(content: string): FAQItem[] {
  const faqSection = content.match(
    /## Sık Sorulan Sorular([\s\S]*?)(?=##|$)/
  );

  if (!faqSection) return [];

  const faqContent = faqSection[1];
  const items: FAQItem[] = [];

  // ### ile başlayan soruları bul
  const questionRegex = /### (.+?\?)\s*\n([\s\S]*?)(?=###|$)/g;
  let match;

  while ((match = questionRegex.exec(faqContent)) !== null) {
    items.push({
      question: match[1].trim(),
      answer: match[2].trim(),
    });
  }

  return items;
}

// Kullanım
const faqItems = extractFAQFromContent(post.content);
if (faqItems.length > 0) {
  const faqSchema = generateFAQSchema(faqItems);
  // Schema'yı ekle
}

// lib/schema.ts
interface HowToStep {
  name: string;
  text: string;
  image?: string;
}

interface HowToInput {
  title: string;
  description: string;
  totalTime?: string; // ISO 8601 format: "PT30M"
  steps: HowToStep[];
  tools?: string[];
  supplies?: string[];
}

export function generateHowToSchema(input: HowToInput) {
  return {
    '@context': 'https://schema.org',
    '@type': 'HowTo',
    name: input.title,
    description: input.description,
    totalTime: input.totalTime,
    tool: input.tools?.map(tool => ({
      '@type': 'HowToTool',
      name: tool,
    })),
    supply: input.supplies?.map(supply => ({
      '@type': 'HowToSupply',
      name: supply,
    })),
    step: input.steps.map((step, index) => ({
      '@type': 'HowToStep',
      position: index + 1,
      name: step.name,
      text: step.text,
      image: step.image,
    })),
  };
}

const howToSchema = generateHowToSchema({
  title: 'Next.js Projesi Nasıl Kurulur',
  description: 'Sıfırdan Next.js projesi oluşturma rehberi',
  totalTime: 'PT15M',
  tools: ['Node.js', 'npm veya yarn', 'Kod editörü'],
  steps: [
    {
      name: 'Node.js Kurulumu',
      text: 'nodejs.org adresinden Node.js indirin ve kurun.',
    },
    {
      name: 'Proje Oluşturma',
      text: 'Terminal açın ve npx create-next-app@latest komutunu çalıştırın.',
    },
    {
      name: 'Geliştirme Sunucusu',
      text: 'npm run dev komutuyla projeyi başlatın.',
    },
  ],
});

// lib/schema.ts
interface ProductInput {
  name: string;
  description: string;
  image: string;
  sku: string;
  brand: string;
  price: number;
  currency: string;
  inStock: boolean;
  rating?: {
    average: number;
    count: number;
  };
}

export function generateProductSchema(input: ProductInput) {
  const schema: Record<string, unknown> = {
    '@context': 'https://schema.org',
    '@type': 'Product',
    name: input.name,
    description: input.description,
    image: input.image,
    sku: input.sku,
    brand: {
      '@type': 'Brand',
      name: input.brand,
    },
    offers: {
      '@type': 'Offer',
      price: input.price,
      priceCurrency: input.currency,
      availability: input.inStock
        ? 'https://schema.org/InStock'
        : 'https://schema.org/OutOfStock',
      url: typeof window !== 'undefined' ? window.location.href : '',
    },
  };

  // Rating varsa ekle
  if (input.rating) {
    schema.aggregateRating = {
      '@type': 'AggregateRating',
      ratingValue: input.rating.average,
      reviewCount: input.rating.count,
    };
  }

  return schema;
}

interface ReviewInput {
  author: string;
  rating: number;
  reviewBody: string;
  datePublished: string;
  productName: string;
}

export function generateReviewSchema(input: ReviewInput) {
  return {
    '@context': 'https://schema.org',
    '@type': 'Review',
    author: {
      '@type': 'Person',
      name: input.author,
    },
    reviewRating: {
      '@type': 'Rating',
      ratingValue: input.rating,
      bestRating: 5,
    },
    reviewBody: input.reviewBody,
    datePublished: input.datePublished,
    itemReviewed: {
      '@type': 'Product',
      name: input.productName,
    },
  };
}

export function generateOrganizationSchema() {
  return {
    '@context': 'https://schema.org',
    '@type': 'Organization',
    name: 'Beydemir.dev',
    url: 'https://beydemir.dev',
    logo: 'https://beydemir.dev/logo.png',
    sameAs: [
      'https://twitter.com/furkanbeydemir',
      'https://github.com/furkanbeydemir',
      'https://linkedin.com/in/furkanbeydemir',
    ],
    contactPoint: {
      '@type': 'ContactPoint',
      email: 'hello@beydemir.dev',
      contactType: 'customer service',
    },
  };
}

interface LocalBusinessInput {
  name: string;
  address: {
    street: string;
    city: string;
    region: string;
    postalCode: string;
    country: string;
  };
  phone: string;
  openingHours: string[];
  geo: {
    latitude: number;
    longitude: number;
  };
}

export function generateLocalBusinessSchema(input: LocalBusinessInput) {
  return {
    '@context': 'https://schema.org',
    '@type': 'LocalBusiness',
    name: input.name,
    address: {
      '@type': 'PostalAddress',
      streetAddress: input.address.street,
      addressLocality: input.address.city,
      addressRegion: input.address.region,
      postalCode: input.address.postalCode,
      addressCountry: input.address.country,
    },
    telephone: input.phone,
    openingHoursSpecification: input.openingHours.map(hours => ({
      '@type': 'OpeningHoursSpecification',
      dayOfWeek: hours.split(' ')[0],
      opens: hours.split(' ')[1]?.split('-')[0],
      closes: hours.split(' ')[1]?.split('-')[1],
    })),
    geo: {
      '@type': 'GeoCoordinates',
      latitude: input.geo.latitude,
      longitude: input.geo.longitude,
    },
  };
}

interface BreadcrumbItem {
  name: string;
  url: string;
}

export function generateBreadcrumbSchema(items: BreadcrumbItem[]) {
  return {
    '@context': 'https://schema.org',
    '@type': 'BreadcrumbList',
    itemListElement: items.map((item, index) => ({
      '@type': 'ListItem',
      position: index + 1,
      name: item.name,
      item: item.url,
    })),
  };
}

// Kullanım
const breadcrumbSchema = generateBreadcrumbSchema([
  { name: 'Ana Sayfa', url: 'https://beydemir.dev' },
  { name: 'Blog', url: 'https://beydemir.dev/blog' },
  { name: 'SEO Rehberi', url: 'https://beydemir.dev/blog/seo-rehberi' },
]);

// scripts/validate-schemas.ts
import { getAllPosts } from '../lib/mdx';
import { generateArticleSchema } from '../lib/schema';

interface ValidationError {
  slug: string;
  field: string;
  message: string;
}

async function validateAllSchemas() {
  const posts = await getAllPosts();
  const errors: ValidationError[] = [];

  for (const post of posts) {
    const schema = generateArticleSchema({
      title: post.title,
      description: post.excerpt,
      slug: post.slug,
      date: post.date,
      author: { name: post.author },
      image: post.imageUrl,
    });

    // Zorunlu alanları kontrol et
    if (!schema.headline) {
      errors.push({
        slug: post.slug,
        field: 'headline',
        message: 'Başlık eksik',
      });
    }

    if (schema.headline && schema.headline.length > 110) {
      errors.push({
        slug: post.slug,
        field: 'headline',
        message: 'Başlık 110 karakteri aşıyor',
      });
    }

    if (!schema.image) {
      errors.push({
        slug: post.slug,
        field: 'image',
        message: 'Görsel URL eksik',
      });
    }

    if (!schema.datePublished) {
      errors.push({
        slug: post.slug,
        field: 'datePublished',
        message: 'Tarih eksik',
      });
    }
  }

  if (errors.length > 0) {
    console.error('Schema hataları bulundu:');
    errors.forEach(e => {
      console.error(`  - ${e.slug}: ${e.field} - ${e.message}`);
    });
    process.exit(1);
  }

  console.log(`✓ ${posts.length} yazı için schema doğrulandı`);
}

validateAllSchemas();

{
  "scripts": {
    "schema:validate": "tsx scripts/validate-schemas.ts"
  }
}

[
  { "@type": "Article", ... },
  { "@type": "FAQPage", ... },
  { "@type": "BreadcrumbList", ... }
]