import { AzureFunction, Context, HttpRequest, HttpResponse } from '@azure/functions'

/** SignalR に接続するためのエンドポイント、アクセストークンを返す */
const httpTrigger: AzureFunction = async function (
  context: Context,
  req: HttpRequest,
  connectionInfo: unknown
): Promise<void> {
  context.res = { body: connectionInfo } satisfies HttpResponse
}

export default httpTrigger

{
  "disabled": false,
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post"],
      "name": "req"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    },
    {
      "type": "signalRConnectionInfo",
      "name": "connectionInfo",
      "hubName": "serverless",
      "userId": "{query.userId}",
      "connectionStringSetting": "AzureSignalRConnectionString",
      "direction": "in"
    }
  ],
  "scriptFile": "../dist/negotiate/index.js"
}

import * as df from 'durable-functions'
import { AzureFunction, Context, HttpRequest, HttpResponse } from '@azure/functions'
import { StatusCodes } from 'http-status-codes'
import { FUNCTION_NAME } from '../lib/constants'
import { OrchestrateQuizChatInput, StartChatRequestBody } from '../lib/types'

/** Quiz Chat のオーケストレーションを開始する */
const httpStart: AzureFunction = async function (
  context: Context,
  req: HttpRequest
): Promise<unknown> {
  const { userId, quizTopic, currentInstanceId } = (req.body ?? {}) as StartChatRequestBody

  if (!userId || !quizTopic) {
    return {
      status: StatusCodes.BAD_REQUEST,
    }
  }

  const client = df.getClient(context)

  // 起動済みのインスタンスがある場合は停止
  if (currentInstanceId) {
    const status = await client.getStatus(currentInstanceId)
    if (status?.runtimeStatus === df.OrchestrationRuntimeStatus.Running) {
      await client.terminate(currentInstanceId, 'Restart New')
    }
  }

  // オーケストレーターを開始
  const input: OrchestrateQuizChatInput = { userId, quizTopic }
  const instanceId = await client.startNew(
    FUNCTION_NAME.orchestrator.orchestrateQuizChat,
    undefined,
    input
  )

  // インスタンスにアクセスするためのURL情報を含んだレスポンスを返す
  return client.createCheckStatusResponse(context.bindingData.req, instanceId)
}

export default httpStart

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": ["post", "options"]
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "starter",
      "type": "orchestrationClient",
      "direction": "in"
    }
  ],
  "scriptFile": "../dist/startQuizChat/index.js"
}

import * as df from 'durable-functions'
import { add } from 'date-fns'
import { FUNCTION_NAME } from '../lib/constants'
import { Task } from 'durable-functions/lib/src/task'
import { IOrchestrationFunctionContext } from 'durable-functions/lib/src/iorchestrationfunctioncontext'
import { ChatMessage, OrchestrateQuizChatInput, Status, StatusMessage } from '../lib/types'

/** 外部イベントとChatGPTへのメッセージ送信を制御する */
const orchestrator = df.orchestrator(function* (context) {
  const input = context.df.getInput<OrchestrateQuizChatInput>()
  const { userId, quizTopic } = input

  // ユーザーがSignalRに接続しているかどうか確認
  const isConnected = yield context.df.callActivity(FUNCTION_NAME.activity.isUserConnected, userId)
  // 接続していなかったら終了
  if (!isConnected) return

  try {
    // ChatGPTの入力中を通知
    yield createNotifyStatusChangeTask(context, userId, 'Typing')
    // クイズの出題依頼を送信
    const requestMessage: ChatMessage = {
      userId,
      content: [
        `${quizTopic}に関するクイズを1問出題してください。`,
        '選択式問題にしてください。',
        '解答は伏せてください。',
      ].join('\n'),
    }
    const question = yield createTalkTask(context, requestMessage)

    // ユーザー入力を待機するタスク("NewMessage" という名前のイベントを監視する)
    const messageMonitorTask = context.df.waitForExternalEvent('NewMessage')
    // 回答期限(30秒)まで待機するタスク
    const deadline = add(context.df.currentUtcDateTime, {
      seconds: 30,
    })
    const deadlineTimer = context.df.createTimer(deadline)

    // いずれかのタスクが完了するまで待機
    const winner = yield context.df.Task.any([messageMonitorTask, deadlineTimer])

    const tasks: Task[] = [
      // 入力中を通知するタスク
      createNotifyStatusChangeTask(context, userId, 'Typing'),
    ]

    // ユーザーの回答を受信したら回答を送信
    if (winner === messageMonitorTask) {
      deadlineTimer.cancel()
      const receivedMessage = messageMonitorTask.result as ChatMessage

      // 回答送信タスク
      const message: ChatMessage = {
        ...receivedMessage,
        currentReply: question,
      }
      tasks.push(createTalkTask(context, message))
    }
    // 時間切れになったら降参のメッセージを送信
    else {
      // 時間切れを通知
      yield createNotifyStatusChangeTask(context, userId, 'TimeUp')

      const message: ChatMessage = {
        userId,
        content: '降参です。答えを教えてください。',
        currentReply: question,
      }
      // 降参メッセージ送信タスク
      tasks.push(createTalkTask(context, message))
    }

    // ChatGPTの入力中を通知するタスクと会話タスクを実行
    yield context.df.Task.all(tasks)
  } catch (error) {
    context.log.error(error)
    // エラーを通知
    yield createNotifyStatusChangeTask(context, userId, 'Error')
    return
  }

  // オーケストレーションを再実行
  context.df.continueAsNew(input)
})

/** 会話タスクを作成 */
const createTalkTask = (context: IOrchestrationFunctionContext, message: ChatMessage): Task => {
  return context.df.callActivity(FUNCTION_NAME.activity.talk, message)
}

/** ステータス変更を通知するタスクを作成 */
const createNotifyStatusChangeTask = (
  context: IOrchestrationFunctionContext,
  userId: string,
  status: Status
): Task => {
  return context.df.callActivity(FUNCTION_NAME.activity.notifyStatus, {
    userId,
    status,
  } satisfies StatusMessage)
}

export default orchestrator

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "scriptFile": "../dist/orchestrateQuizChat/index.js"
}

import { AzureFunction, Context } from '@azure/functions'
import { StatusCodes } from 'http-status-codes'
import { sign } from 'jsonwebtoken'

const API_ENDPOINT_BASE = '/api/v1/hubs/serverless/users/'

/** ユーザーが SignalR に接続しているかどうか確認する */
const activityFunction: AzureFunction = async function (
  context: Context,
  userId: string
): Promise<boolean> {
  const apiEndpoint = `${API_ENDPOINT_BASE}${userId}`
  const { url, accessToken } = createSignalRAccessToken(apiEndpoint)

  try {
    // Azure SignalR Service REST API にリクエスト発行
    const response = await fetch(url, {
      method: 'HEAD',
      headers: {
        Authorization: `Bearer ${accessToken}`,
      },
    })

    // 未接続の場合はステータスコード = 404 となる
    return response.status === StatusCodes.OK
  } catch (error) {
    context.log.error(error)
    return false
  }
}

/** SignalR の接続文字列からエンドポイントとシークレットを取得する */
const parseSignalRConnectionString = () => {
  const connectionString = process.env['AzureSignalRConnectionString']
  if (!connectionString) throw Error("Missing env: 'AzureSignalRConnectionString'")

  const [endpoint, key] = connectionString.split(';')

  return {
    endpoint: endpoint.replace('Endpoint=', ''),
    key: key.replace('AccessKey=', ''),
  }
}

/** Azure SignalR Service REST API のアクセストークンを生成する */
const createSignalRAccessToken = (endpoint: string) => {
  const { endpoint: origin, key } = parseSignalRConnectionString()
  const audience = `${origin}${endpoint}`
  const accessToken = sign({ aud: audience }, key, { expiresIn: '1h' })
  return { url: audience, accessToken }
}

export default activityFunction

{
  "bindings": [
    {
      "name": "userId",
      "type": "activityTrigger",
      "direction": "in"
    }
  ],
  "scriptFile": "../dist/isUserConnected/index.js"
}

import { AzureFunction, Context } from '@azure/functions'
import { StatusMessage } from '../lib/types'
import { SIGNALR_MESSAGE } from '../lib/constants'

/** ステータスの変更をクライアントに通知する */
const activityFunction: AzureFunction = async function (
  context: Context,
  message: StatusMessage
): Promise<void> {
  const { userId, status } = message

  // "StatusChanged" という名前でメッセージ通知する
  context.bindings.signalRMessages = [
    { userId, target: SIGNALR_MESSAGE.statusChanged, arguments: [status] },
  ]
}

export default activityFunction

{
  "bindings": [
    {
      "name": "status",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "signalR",
      "name": "signalRMessages",
      "hubName": "serverless",
      "connectionStringSetting": "AzureSignalRConnectionString",
      "direction": "out"
    }
  ],
  "scriptFile": "../dist/notifyStatus/index.js"
}

import { AzureFunction, Context } from '@azure/functions'
import { ChatCompletionRequestMessage, Configuration, OpenAIApi } from 'openai'
import { ChatMessage } from '../lib/types'
import { SIGNALR_MESSAGE } from '../lib/constants'

/** ChatGPT にメッセージを送信して返答を返す */
const activityFunction: AzureFunction = async function (
  context: Context,
  message: ChatMessage
): Promise<string> {
  const apiKey = process.env['OPEN_AI_API_KEY']
  if (!apiKey) throw Error('Missing OpenAI Key')

  const configuration = new Configuration({ apiKey })
  const openai = new OpenAIApi(configuration)

  const { userId, content, currentReply } = message
  const messages: ChatCompletionRequestMessage[] = [
    // AIの設定
    {
      role: 'system',
      content: 'あなたはクイズの出題者です。日本語で返答してください。',
    },
  ]
  // 直近でChatGPTが発言した内容を設定
  if (currentReply) messages.push({ role: 'assistant', content: currentReply })

  // ユーザーのメッセージ
  messages.push({ role: 'user', content })

  // ChatGPTにメッセージ送信
  const reply = await sendMessageToChatGPT(context, openai, messages)
  if (!reply) throw Error('Could not retrieve reply.')

  // "Reply" という名前でメッセージ通知する
  context.bindings.signalRMessages = [{ userId, target: SIGNALR_MESSAGE.reply, arguments: [reply] }]

  return reply
}

/** ChatGPT にメッセージ送信 */
const sendMessageToChatGPT = async (
  context: Context,
  openai: OpenAIApi,
  messages: ChatCompletionRequestMessage[]
): Promise<string | undefined> => {
  const completion = await openai.createChatCompletion(
    { model: 'gpt-3.5-turbo', max_tokens: 400, messages },
    { timeout: 120000 }
  )

  const reply = completion.data.choices[0].message?.content
  return reply
}

export default activityFunction

{
  "bindings": [
    {
      "name": "message",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "signalR",
      "name": "signalRMessages",
      "hubName": "serverless",
      "connectionStringSetting": "AzureSignalRConnectionString",
      "direction": "out"
    }
  ],
  "scriptFile": "../dist/talk/index.js"
}

/** startChat API のリクエストボディ */
type StartChatRequestBody = {
  userId?: string
  quizTopic?: string
  currentInstanceId?: string
}

/** orchestrateQuizChat API の入力 */
type OrchestrateQuizChatInput = {
  userId: string
  quizTopic: string
}

/** talk API の入力 */
type ChatMessage = {
  userId: string
  content: string
  currentReply?: string
}

/** notifyStatus API の入力 */
type StatusMessage = {
  userId: string
  status: Status
}

/** サーバーステータス */
type Status = 'Typing' | 'TimeUp' | 'Error'

export type { ChatMessage, OrchestrateQuizChatInput, StartChatRequestBody, StatusMessage, Status }

/** 関数名 */
const FUNCTION_NAME = {
  orchestrator: {
    orchestrateQuizChat: 'orchestrateQuizChat',
  },
  activity: {
    isUserConnected: 'isUserConnected',
    talk: 'talk',
    notifyStatus: 'notifyStatus',
  },
} as const

/** Azure SignalR のメッセージ名 */
const SIGNALR_MESSAGE = {
  reply: 'Reply',
  statusChanged: 'StatusChanged',
}

export { FUNCTION_NAME, SIGNALR_MESSAGE }

api
├── host.json
├── isUserConnected
│   ├── function.json
│   └── index.ts
├── lib
│   ├── constants.ts
│   └── types.ts
├── local.settings.json
├── negotiate
│   ├── function.json
│   └── index.ts
├── notifyStatus
│   ├── function.json
│   └── index.ts
├── orchestrateQuizChat
│   ├── function.json
│   └── index.ts
├── package-lock.json
├── package.json
├── startQuizChat
│   ├── function.json
│   └── index.ts
├── talk
│   ├── function.json
│   └── index.ts
└── tsconfig.json