import { createClient } from '@supabase/supabase-js';
import { revalidatePath } from 'next/cache';

// 共通のバリデーション関数
const validatePokemonData = (data: { name?: string }) => {
  const errors: { [key: string]: string } = {};

  if (!data.name || typeof data.name !== 'string' || data.name.trim() === '') {
    errors.name = 'Invalid or missing Pokemon name';
  }

  // 他のフィールドのバリデーションをここに追加

  return errors;
};

// 共通のSupabase操作関数
const performSupabaseOperation = async (operation: 'insert' | 'update', data: any, id?: string) => {
  const supabase = createClient();
  let query = supabase.from('pokemons');

  if (operation === 'insert') {
    query = query.insert(data);
  } else if (operation === 'update' && id) {
    query = query.update(data).eq('id', id);
  } else {
    throw new Error('Invalid operation or missing ID for update');
  }

  const { data: result, error } = await query.select();
  if (error) throw error;
  return result;
};

// createPokemon 関数
export const createPokemon = async (form: FormData) => {
  const user = await getUser();
  if (!user) {
    throw new Error('User not authenticated');
  }

  const name = form.get('name') as string;
  const errors = validatePokemonData({ name });

  if (Object.keys(errors).length > 0) {
    throw new Error(Object.values(errors).join(', '));
  }

  try {
    const data = await performSupabaseOperation('insert', {
      name: name.trim(),
      trainerId: user.id,
      level: 1,
    });

    revalidatePath('/pokemon');
    return data;
  } catch (error) {
    console.error('Error creating Pokemon:', error);
    throw new Error('Failed to create Pokemon');
  }
};

// updatePokemon 関数 (例)
export const updatePokemon = async (id: string, form: FormData) => {
  // ユーザー認証やその他の前処理

  const name = form.get('name') as string;
  const errors = validatePokemonData({ name });

  if (Object.keys(errors).length > 0) {
    throw new Error(Object.values(errors).join(', '));
  }

  try {
    const data = await performSupabaseOperation('update', { name: name.trim() }, id);
    revalidatePath('/pokemon');
    return data;
  } catch (error) {
    console.error('Error updating Pokemon:', error);
    throw new Error('Failed to update Pokemon');
  }
};

import { z } from 'zod';

const FormSchema = z.object({
  id: z.string(),
  customerId: z.string(),
  amount: z.coerce.number(),
  status: z.enum(['pending', 'paid']),
  date: z.string(),
});

const CreateInvoice = FormSchema.omit({ id: true, date: true });

export async function createInvoice(formData: FormData) {
  try {
    const { customerId, amount, status } = CreateInvoice.parse({
      customerId: formData.get('customerId'),
      amount: formData.get('amount'),
      status: formData.get('status'),
    });

    // バリデーション成功後の処理（例：データベースへの保存）

  } catch (error) {
    if (error instanceof z.ZodError) {
      // バリデーションエラーの処理
      console.error(error.errors);
    }
  }
}

try {
  const validatedData = CreateInvoice.parse(rawFormData);
  // 検証成功時の処理
} catch (error) {
  if (error instanceof z.ZodError) {
    console.error('Validation failed:', error.errors);
    // エラーハンドリング（例：ユーザーへのフィードバック表示）
  }
}

// middleware.ts
import { createMiddlewareClient } from '@supabase/auth-helpers-nextjs'
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export async function middleware(req: NextRequest) {
  const res = NextResponse.next()
  const supabase = createMiddlewareClient({ req, res })
  const { data: { session } } = await supabase.auth.getSession()

  const isLoggedIn = !!session
  const path = req.nextUrl.pathname

  // ログインチェック
  if (path.startsWith('/dashboard') && !isLoggedIn) {
    return NextResponse.redirect(new URL('/login', req.url))
  }

  // 組織関連のチェック（例：ダッシュボードへのアクセス）
  if (path.startsWith('/dashboard') && isLoggedIn) {
    const { data: userOrg } = await supabase
      .from('user_organizations')
      .select('organization_id')
      .eq('user_id', session.user.id)
      .single()

    if (!userOrg) {
      return NextResponse.redirect(new URL('/no-organization', req.url))
    }

    const { data: org } = await supabase
      .from('organizations')
      .select()
      .eq('id', userOrg.organization_id)
      .single()

    if (!org) {
      return NextResponse.redirect(new URL('/organization-not-found', req.url))
    }
  }

  return res
}

export const config = {
  matcher: ['/((?!api|_next/static|_next/image|favicon.ico).*)'],
}

// app/dashboard/layout.tsx
import { createServerComponentClient } from '@supabase/auth-helpers-nextjs'
import { cookies } from 'next/headers'
import { redirect } from 'next/navigation'

export default async function DashboardLayout({
  children,
}: {
  children: React.ReactNode
}) {
  const supabase = createServerComponentClient({ cookies })
  const { data: { session } } = await supabase.auth.getSession()

  if (!session) {
    redirect('/login')
  }

  // 組織チェック
  const { data: userOrg } = await supabase
    .from('user_organizations')
    .select('organization_id')
    .eq('user_id', session.user.id)
    .single()

  if (!userOrg) {
    redirect('/no-organization')
  }

  const { data: org } = await supabase
    .from('organizations')
    .select()
    .eq('id', userOrg.organization_id)
    .single()

  if (!org) {
    redirect('/organization-not-found')
  }

  // ユーザーの権限チェック（例：管理者のみアクセス可能なページ）
  const isAdminPage = location.pathname.startsWith('/dashboard/admin')
  if (isAdminPage) {
    const { data: userRole } = await supabase
      .from('user_roles')
      .select('role')
      .eq('user_id', session.user.id)
      .single()

    if (userRole?.role !== 'admin') {
      redirect('/dashboard') // 一般ダッシュボードにリダイレクト
    }
  }

  return <div>{children}</div>
}

// app/no-organization/page.tsx
export default function NoOrganizationPage() {
  return (
    <div>
      <h1>No Organization</h1>
      <p>You are not registered to any organization. Please contact an administrator.</p>
    </div>
  )
}

// app/organization-not-found/page.tsx
export default function OrganizationNotFoundPage() {
  return (
    <div>
      <h1>Organization Not Found</h1>
      <p>The organization you are registered to no longer exists. Please contact support.</p>
    </div>
  )
}

// utils/checkAccess.ts
import { createServerComponentClient } from '@supabase/auth-helpers-nextjs'
import { cookies } from 'next/headers'
import { redirect } from 'next/navigation'

export async function checkAccess(requiredRole: string = 'user') {
  const supabase = createServerComponentClient({ cookies })
  const { data: { session } } = await supabase.auth.getSession()

  if (!session) {
    redirect('/login')
  }

  const { data: userRole } = await supabase
    .from('user_roles')
    .select('role')
    .eq('user_id', session.user.id)
    .single()

  if (userRole?.role !== requiredRole) {
    redirect('/unauthorized')
  }

  return session
}

// app/dashboard/admin/page.tsx
import { checkAccess } from '@/utils/checkAccess'

export default async function AdminPage() {
  await checkAccess('admin')

  return (
    <div>
      <h1>Admin Dashboard</h1>
      {/* Admin content */}
    </div>
  )
}

// middleware.ts
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export function middleware(request: NextRequest) {
  const session = request.cookies.get('session')
  if (!session && !request.nextUrl.pathname.startsWith('/login')) {
    return NextResponse.redirect(new URL('/login', request.url))
  }
}

export const config = {
  matcher: ['/dashboard/:path*', '/profile/:path*'],
}

// app/dashboard/page.tsx
import { getServerSession } from "next-auth/next"
import { redirect } from 'next/navigation'

async function getDashboardData(token: string) {
  const res = await fetch('https://api.example.com/dashboard-data', {
    headers: {
      'Authorization': `Bearer ${token}`
    },
    cache: 'no-store' // キャッシュを無効化
  })
  if (!res.ok) throw new Error('Failed to fetch dashboard data')
  return res.json()
}

export default async function DashboardPage() {
  const session = await getServerSession()
  if (!session) redirect('/login')

  const dashboardData = await getDashboardData(session.accessToken)

  return (
    <div>
      <h1>Dashboard</h1>
      {/* dashboardDataを使用してUIをレンダリング */}
    </div>
  )
}

'use client'

import { useState, useEffect } from 'react'
import { useSession } from 'next-auth/react'

export default function SensitiveDataComponent() {
  const { data: session } = useSession()
  const [sensitiveData, setSensitiveData] = useState(null)

  useEffect(() => {
    if (session) {
      fetchSensitiveData()
    }
  }, [session])

  async function fetchSensitiveData() {
    const res = await fetch('/api/sensitive-data', {
      headers: {
        'Authorization': `Bearer ${session.accessToken}`
      }
    })
    if (res.ok) {
      const data = await res.json()
      setSensitiveData(data)
    }
  }

  if (!session) return <div>Please log in to view this content</div>

  return (
    <div>
      {/* センシティブなデータを表示 */}
    </div>
  )
}

// app/api/sensitive-data/route.ts
import { getServerSession } from "next-auth/next"
import { NextResponse } from 'next/server'

export async function GET() {
  const session = await getServerSession()
  if (!session) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
  }

  // ユーザーの権限チェック
  if (!hasPermission(session.user, 'read:sensitive-data')) {
    return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
  }

  // センシティブなデータを取得
  const sensitiveData = await fetchSensitiveData(session.user.id)

  return NextResponse.json(sensitiveData)
}

// app/dashboard/layout.tsx
export const revalidate = 0 // このセグメント以下のすべてのルートで動的レンダリングを強制

export default function DashboardLayout({ children }) {
  return <div>{children}</div>
}

// middleware.js
export const config = {
  matcher: '/about/:path*',
}

// middleware.js
export const config = {
  matcher: ['/about/:path*', '/dashboard/:path*'],
}

// middleware.js
export const config = {
  matcher: [
    /*
     * Match all request paths except for the ones starting with:
     * - api (API routes)
     * - _next/static (static files)
     * - _next/image (image optimization files)
     * - favicon.ico (favicon file)
     */
    '/((?!api|_next/static|_next/image|favicon.ico).*)',
  ],
}

import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export function middleware(request: NextRequest) {
  if (request.nextUrl.pathname.startsWith('/about')) {
    return NextResponse.rewrite(new URL('/about-2', request.url))
  }

  if (request.nextUrl.pathname.startsWith('/dashboard')) {
    return NextResponse.rewrite(new URL('/dashboard/user', request.url))
  }

  // 追加の条件を設定可能
  if (request.nextUrl.pathname.startsWith('/blog')) {
    const authToken = request.cookies.get('authToken')
    if (!authToken) {
      return NextResponse.redirect(new URL('/login', request.url))
    }
  }
}

// middleware.ts
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export const config = {
  matcher: ['/dashboard/:path*', '/api/:path*'],
}

export function middleware(request: NextRequest) {
  if (request.nextUrl.pathname.startsWith('/dashboard')) {
    const authToken = request.cookies.get('authToken')
    if (!authToken) {
      return NextResponse.redirect(new URL('/login', request.url))
    }
  }

  if (request.nextUrl.pathname.startsWith('/api')) {
    const apiKey = request.headers.get('x-api-key')
    if (!apiKey) {
      return new NextResponse(
        JSON.stringify({ error: 'Missing API key' }),
        { status: 401, headers: { 'content-type': 'application/json' } }
      )
    }
  }
}