interface UploadNewImageUseCaseDependencies {
  imageStoreRepo: ImageStoreRepo
  imageMetadataRepo: ImageMetadataRepo
}

export function uploadNewImageUseCase(deps: UploadNewImageUseCaseDependencies) {
  return async (
    imageData: ArrayBuffer,
    metadata: {
      prompt: ImagePrompt
      modelName: string
      createdAt?: Date
      imageExtension: string
    },
  ) => {
    // ここからロジック
    const { prompt, modelName, createdAt = new Date(), imageExtension: ext } = metadata
    const filename = `${format(createdAt, 'yyyy-MM-dd-HH-mm-ss')}${ext}`

    const imageUri = await deps.imageStoreRepo.upload(filename, imageData)
    try {
      const metadataRecord = { id: uuidv7(), prompt, modelName, createdAt, imageUri }
      await deps.imageMetadataRepo.add(metadataRecord)
    } catch (e) {
      console.error(e)
      await deps.imageStoreRepo.delete(filename)
      throw e
    }
  }
}

export function uploadNewImageUseCase(deps: UploadNewImageUseCaseDependencies) {
  return async (...args) => {
    // 依存注入後の関数
  }
}

export interface ImageStoreRepo {
  upload: (filename: string, imageData: ArrayBuffer) => Promise<string> // 戻り値はURI
  download: (filename: string) => Promise<ArrayBuffer> // 画像データを取得
  delete: (filename: string) => Promise<void> // 画像データを削除
}

import { getContext } from 'hono/context-storage'
import { ImageStoreRepo } from '../../domain/repos/image-store-repo'

export const imageStoreRepoCloudflareR2: ImageStoreRepo = { // ImageStoreRepo を実装
  upload: async (filename: string, imageData: ArrayBuffer) => {
    const c = getContext<Env>()
    const filePath = toR2Key(filename)
    await c.env.BUCKET.put(filePath, imageData)
    return `https://media.trpfrog.net/${filePath}`
  },

  download: async (filename: string) => {
    const c = getContext<Env>()
    const filePath = toR2Key(filename)
    const res = await c.env.BUCKET.get(filePath)
    if (res === null) {
      throw new Error('Not found')
    }
    return await res.arrayBuffer()
  },

  delete: async (filename: string) => {
    const c = getContext<Env>()
    const filePath = toR2Key(filename)
    await c.env.BUCKET.delete(filePath)
  },
}

import { UseCases } from '../wire'

export function createApp(ucs: UseCases) {
  return new Hono<Env>()
    // ...
    .get('/current', async c => {
      const arrayBuffer = await ucs.currentImage()
      return c.newResponse(arrayBuffer)
    })
    // ...
}

import { z } from 'zod'

import { createApp } from './controller'
import { prepareUsecasesBuilder } from './wire'

// インフラ層の実装
import { imageMetadataRepoCloudflareD1WithKV } from './infra/repos/imageMetadataRepoCloudflareD1WithKV'
import { imageStoreRepoCloudflareR2 } from './infra/repos/imageStoreRepoCloudflareR2'
import { createOpenAIChatLLMJson } from './infra/services/llm'
import { randomWordApi } from './infra/services/random-words'
import { createHfImageGenerator } from './infra/services/text-to-image'

const env = z
  .object({
    HUGGINGFACE_TOKEN: z.string(),
    OPENAI_API_KEY: z.string(),
  })
  // eslint-disable-next-line n/no-process-env
  .parse(process.env)

const app = createApp(
  prepareUsecasesBuilder({
    imageStoreRepo: imageStoreRepoCloudflareR2,
    imageMetadataRepo: imageMetadataRepoCloudflareD1WithKV,
    textToImage: createHfImageGenerator({
      modelName: 'Prgckwb/trpfrog-sd3.5-large-lora',
      hfToken: env.HUGGINGFACE_TOKEN,
    }),
    jsonChatbot: createOpenAIChatLLMJson({
      model: 'gpt-4o-2024-11-20',
      temperature: 0.9,
      apiKey: env.OPENAI_API_KEY,
    }),
    generateSeedWords: () => randomWordApi(10),
  })
)

import * as rawUsecases from './usecases'

// 共通の依存関係を受け取る型を定義
type CommonDependencies = {
  imageStoreRepo: ImageStoreRepo
  imageMetadataRepo: ImageMetadataRepo
  textToImage: TextToImage
  jsonChatbot: ChatLLMJson
  generateSeedWords: () => Promise<string[]>
}

// ユースケースを手動で組み立てる関数
export function prepareUsecasesBuilder(common: CommonDependencies): UseCases {
  const { imageStoreRepo, imageMetadataRepo, textToImage, jsonChatbot, generateSeedWords } = common

  // 基本的なユースケースのインスタンスを作成
  const currentImage = rawUsecases.currentImageUseCase({ imageMetadataRepo, imageStoreRepo })
  const currentMetadata = rawUsecases.currentMetadataUseCase({ imageMetadataRepo })
  const generateImage = rawUsecases.generateImageUseCase({ textToImage })
  const generatePromptFromWords = rawUsecases.generatePromptFromWordsUseCase({ jsonChatbot })
  const generateRandomWords = rawUsecases.generateRandomWordsUseCase({ generateSeedWords })
  const uploadNewImage = rawUsecases.uploadNewImageUseCase({ imageMetadataRepo, imageStoreRepo })
  const queryImageMetadata = rawUsecases.queryImageMetadataUseCase({ imageMetadataRepo })

  // 依存関係を持つ派生ユースケースのインスタンスを作成
  const generateRandomImage = rawUsecases.generateRandomImageUseCase({
    generateImage: (prompt: string) => generateImage(prompt, { numberOfRetries: 3 }),
    generatePromptFromSeedWords: (seedWords: string[]) => generatePromptFromWords(seedWords),
    generateSeedWords: generateRandomWords,
  })

  const refreshImageIfStale = rawUsecases.refreshImageIfStaleUseCase({
    imageMetadataRepo,
    uploadImage: uploadNewImage,
    imageGenerator: generateRandomImage,
  })

  return {
    currentImage,
    currentMetadata,
    generateImage,
    generatePromptFromWords,
    generateRandomWords,
    uploadNewImage,
    queryImageMetadata,
    generateRandomImage,
    refreshImageIfStale,
  }
}

const app = new Hono()
  .get('/current', async c => {
    // `c.env.BUCKET` で R2 にアクセスできる
    const arrayBuffer = await c.env.BUCKET.get('current')  
    return c.newResponse(arrayBuffer)
  })

import { contextStorage } from 'hono/context-storage'

const app = new Hono()
  .use(contextStorage()) 
  .get('/current', async c => {
    // ...
  })

import { getContext } from 'hono/context-storage'

export const imageStoreRepoCloudflareR2: ImageStoreRepo = {
  upload: async (filename: string, imageData: ArrayBuffer) => {
    const c = getContext<Env>() 
    const filePath = toR2Key(filename)
    await c.env.BUCKET.put(filePath, imageData)
    // ...
  },
  // ...
}