// Dify API URL configuration - add to Cloudflare Worker secrets or environment variables
const DIFY_API_URL = "https://api.dify.ai/v1"; // Replace with your Dify API URL

// Bot type configuration (Chat, Completion, or Workflow)
const BOT_TYPE = "Chat"; // You can change this or make it configurable

// Optional input/output variable names for specific bot types
const INPUT_VARIABLE = ""; // Optional: Set if needed for specific bot configurations
const OUTPUT_VARIABLE = ""; // Optional: Set if needed for specific bot configurations

const USER = "default-user"; // Set your preferred default user identifier

// Determine API path based on bot type
let API_PATH;
switch (BOT_TYPE) {
  case "Chat":
    API_PATH = "/chat-messages";
    break;
  case "Completion":
    API_PATH = "/completion-messages";
    break;
  case "Workflow":
    API_PATH = "/workflows/run";
    break;
  default:
    API_PATH = "/chat-messages"; // Default to chat
}

/**
 * Generate a random ID similar to OpenAI's format
 */
function generateId() {
  let result = "";
  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  for (let i = 0; i < 29; i++) {
    result += characters.charAt(Math.floor(Math.random() * characters.length));
  }
  return result;
}

/**
 * Handle CORS preflight requests
 */
function handleCorsHeaders(request) {
  const corsHeaders = {
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
    "Access-Control-Allow-Headers":
      "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization",
    "Access-Control-Max-Age": "86400",
  };

  // Handle OPTIONS request for CORS preflight
  if (request && request.method === "OPTIONS") {
    return new Response(null, {
      status: 204,
      headers: corsHeaders
    });
  }

  return corsHeaders;
}

/**
 * Format response with appropriate headers
 */
function getResponse(body, status = 200, additionalHeaders = {}) {
  const corsHeaders = {
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
    "Access-Control-Allow-Headers":
      "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization",
    "Access-Control-Max-Age": "86400",
  };
  
  return new Response(body, {
    status: status,
    headers: {
      "Content-Type": "application/json",
      ...corsHeaders,
      ...additionalHeaders
    }
  });
}

/**
 * Transform messages into Dify query format based on bot type
 */
function formatDifyQuery(messages, botType) {
  let queryString;
  if (botType === 'Chat') {
    const lastMessage = messages[messages.length - 1];
    queryString = `here is our talk history:\n'''\n${messages
      .slice(0, -1)
      .map((message) => `${message.role}: ${message.content}`)
      .join('\n')}\n'''\n\nhere is my question:\n${lastMessage.content}`;
  } else if (botType === 'Completion' || botType === 'Workflow') {
    queryString = messages[messages.length - 1].content;
  }
  return queryString;
}

/**
 * Build Dify API request body
 */
function buildDifyRequestBody(queryString, inputVariable) {
  if (inputVariable) {
    return {
      inputs: { [inputVariable]: queryString },
      response_mode: "streaming",
      conversation_id: "",
      user: USER,
      auto_generate_name: false
    };
  } else {
    return {
      "inputs": {},
      query: queryString,
      response_mode: "streaming",
      conversation_id: "",
      user: USER,
      auto_generate_name: false
    };
  }
}

/**
 * Process Dify API streaming response
 */
async function handleStreamingResponse(responseBody, model, transformController) {
  const reader = responseBody.getReader();
  const encoder = new TextEncoder();
  let buffer = "";
  let isFirstChunk = true;
  let isResponseEnded = false;

  while (true) {
    const { done, value } = await reader.read();
    
    if (done) {
      // Send final [DONE] marker if not already sent
      if (!isResponseEnded) {
        const doneData = encoder.encode("data: [DONE]\n\n");
        transformController.enqueue(doneData);
      }
      break;
    }

    buffer += new TextDecoder().decode(value);
    const lines = buffer.split("\n");
    
    // Process all complete lines
    for (let i = 0; i < lines.length - 1; i++) {
      let line = lines[i].trim();
      
      if (!line.startsWith("data:")) continue;
      line = line.slice(5).trim();
      
      let chunkObj;
      try {
        if (line.startsWith("{")) {
          chunkObj = JSON.parse(line);
        } else {
          continue;
        }
      } catch (error) {
        console.error("Error parsing chunk:", error);
        continue;
      }

      if (chunkObj.event === "message" || chunkObj.event === "agent_message" || chunkObj.event === "text_chunk") {
        let chunkContent;
        if (chunkObj.event === "text_chunk") {
          chunkContent = chunkObj.data.text;
        } else {
          chunkContent = chunkObj.answer;
        }

        if (isFirstChunk) {
          chunkContent = chunkContent.trimStart();
          isFirstChunk = false;
        }
        
        if (chunkContent !== "" && !isResponseEnded) {
          const chunkId = `chatcmpl-${Date.now()}`;
          const chunkCreated = chunkObj.created_at;
          
          const chunk = {
            id: chunkId,
            object: "chat.completion.chunk",
            created: chunkCreated,
            model: model,
            choices: [
              {
                index: 0,
                delta: {
                  content: chunkContent,
                },
                finish_reason: null,
              },
            ],
          };
          
          const stringifiedChunk = JSON.stringify(chunk);
          const formattedChunk = `data: ${stringifiedChunk}\n\n`;
          transformController.enqueue(encoder.encode(formattedChunk));
        }
      } else if (chunkObj.event === "workflow_finished" || chunkObj.event === "message_end") {
        if (!isResponseEnded) {
          const chunkId = `chatcmpl-${Date.now()}`;
          const chunkCreated = chunkObj.created_at;
          
          const chunk = {
            id: chunkId,
            object: "chat.completion.chunk",
            created: chunkCreated,
            model: model,
            choices: [
              {
                index: 0,
                delta: {},
                finish_reason: "stop",
              },
            ],
          };
          
          const stringifiedChunk = JSON.stringify(chunk);
          const formattedChunk = `data: ${stringifiedChunk}\n\n`;
          transformController.enqueue(encoder.encode(formattedChunk));
          
          // Send [DONE] to signal the end of the stream
          const doneData = encoder.encode("data: [DONE]\n\n");
          transformController.enqueue(doneData);
          isResponseEnded = true;
        }
      } else if (chunkObj.event === "error") {
        console.error(`Error: ${chunkObj.code}, ${chunkObj.message}`);
        if (!isResponseEnded) {
          const errorChunk = `data: ${JSON.stringify({ error: chunkObj.message })}\n\n`;
          transformController.enqueue(encoder.encode(errorChunk));
          
          const doneData = encoder.encode("data: [DONE]\n\n");
          transformController.enqueue(doneData);
          isResponseEnded = true;
        }
      }
      // Silently skip agent_thought and ping events
    }

    buffer = lines[lines.length - 1];
  }
}

/**
 * Process Dify API non-streaming response
 */
async function handleNonStreamingResponse(responseBody, model, outputVariable) {
  let result = "";
  let usageData = null;
  let hasError = false;
  let messageEnded = false;
  let buffer = "";
  let skipWorkflowFinished = false;
  
  const reader = responseBody.getReader();
  
  while (true) {
    const { done, value } = await reader.read();
    
    if (done) break;
    
    buffer += new TextDecoder().decode(value);
    const lines = buffer.split("\n");
    
    for (let i = 0; i < lines.length - 1; i++) {
      const line = lines[i].trim();
      if (line === "") continue;
      
      let chunkObj;
      try {
        const cleanedLine = line.replace(/^data: /, "").trim();
        if (cleanedLine.startsWith("{") && cleanedLine.endsWith("}")) {
          chunkObj = JSON.parse(cleanedLine);
        } else {
          continue;
        }
      } catch (error) {
        console.error("Error parsing JSON:", error);
        continue;
      }
      
      if (chunkObj.event === "message" || chunkObj.event === "agent_message") {
        result += chunkObj.answer;
        skipWorkflowFinished = true;
      } else if (chunkObj.event === "message_end") {
        messageEnded = true;
        usageData = {
          prompt_tokens: chunkObj.metadata?.usage?.prompt_tokens || 100,
          completion_tokens: chunkObj.metadata?.usage?.completion_tokens || 10,
          total_tokens: chunkObj.metadata?.usage?.total_tokens || 110,
        };
      } else if (chunkObj.event === "workflow_finished" && !skipWorkflowFinished) {
        messageEnded = true;
        const outputs = chunkObj.data.outputs;
        if (outputVariable) {
          result = outputs[outputVariable];
        } else {
          result = outputs;
        }
        result = String(result);
        usageData = {
          prompt_tokens: chunkObj.metadata?.usage?.prompt_tokens || 100,
          completion_tokens: chunkObj.metadata?.usage?.completion_tokens || 10,
          total_tokens: chunkObj.data?.total_tokens || 110,
        };
      } else if (chunkObj.event === "error") {
        console.error(`Error: ${chunkObj.code}, ${chunkObj.message}`);
        hasError = true;
        break;
      }
      // Silently skip agent_thought and ping events
    }
    
    buffer = lines[lines.length - 1];
  }
  
  if (hasError) {
    return { error: "An error occurred while processing the request.", status: 500 };
  }
  
  if (messageEnded) {
    return {
      response: {
        id: `chatcmpl-${generateId()}`,
        object: "chat.completion",
        created: Math.floor(Date.now() / 1000),
        model: model,
        choices: [
          {
            index: 0,
            message: {
              role: "assistant",
              content: result.trim(),
            },
            logprobs: null,
            finish_reason: "stop",
          },
        ],
        usage: usageData,
        system_fingerprint: "fp_2f57f81c11",
      },
      status: 200
    };
  }
  
  return { error: "Unexpected end of stream.", status: 500 };
}

/**
 * Main request handler
 */
async function handleRequest(request) {
  try {
    // Handle CORS preflight requests
    if (request.method === "OPTIONS") {
      return new Response(null, {
        status: 204,
        headers: {
          "Access-Control-Allow-Origin": "*",
          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
          "Access-Control-Allow-Headers":
            "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization",
          "Access-Control-Max-Age": "86400",
        }
      });
    }

    // Home page for health check
    const url = new URL(request.url);
    if (request.method === "GET" && url.pathname === "/") {
      return new Response(`
        <html>
          <head>
            <title>DIFY2OPENAI</title>
          </head>
          <body>
            <h1>Dify2OpenAI</h1>
            <p>Congratulations! Your project has been successfully deployed.</p>
          </body>
        </html>
      `, {
        headers: {
          "Content-Type": "text/html",
          "Access-Control-Allow-Origin": "*",
          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
          "Access-Control-Allow-Headers":
            "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization"
        }
      });
    }

    // Validate API endpoint
    if (url.pathname !== "/v1/chat/completions") {
      return getResponse(JSON.stringify({ error: "Not Found" }), 404);
    }

    // Check for Authorization header
    const authHeader = request.headers.get("authorization") || request.headers.get("Authorization");
    if (!authHeader || !authHeader.startsWith("Bearer ")) {
      return getResponse(JSON.stringify({
        code: 401,
        errmsg: "Unauthorized. Missing or invalid Authorization header.",
      }), 401);
    }

    // Parse request body
    const data = await request.json();
    const messages = data.messages || [];
    const stream = data.stream !== undefined ? data.stream : false;
    const model = data.model || "gpt-3.5-turbo"; // Default model identifier

    // Format Dify query from messages
    const queryString = formatDifyQuery(messages, BOT_TYPE);
    
    // Build Dify API request body
    const requestBody = buildDifyRequestBody(queryString, INPUT_VARIABLE);
    
    console.log("Sending request to Dify API:", DIFY_API_URL + API_PATH);

    // Make request to Dify API - passing through the same Authorization header
    const difyResponse = await fetch(DIFY_API_URL + API_PATH, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: authHeader, // Use the same Authorization header received from the client
      },
      body: JSON.stringify(requestBody),
    });

    if (!difyResponse.ok) {
      const errorText = await difyResponse.text();
      return getResponse(JSON.stringify({
        error: `Error from Dify API: ${difyResponse.status} ${difyResponse.statusText}`,
        details: errorText
      }), difyResponse.status);
    }

    // Handle streaming response
    if (stream) {
      const { readable, writable } = new TransformStream();
      const writer = writable.getWriter();
      
      // Create a transformer controller for handling the stream
      const transformController = {
        enqueue: (chunk) => writer.write(chunk),
        close: () => writer.close(),
        error: (err) => writer.abort(err)
      };
      
      // Process the streaming response in background
      handleStreamingResponse(difyResponse.body, model, transformController)
        .catch((error) => {
          console.error("Error processing stream:", error);
          writer.abort(error);
        })
        .finally(() => {
          writer.close();
        });
      
      // Return the readable stream with appropriate headers
      return new Response(readable, {
        headers: {
          "Content-Type": "text/event-stream",
          "Cache-Control": "no-cache",
          "Connection": "keep-alive",
          "Access-Control-Allow-Origin": "*",
          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
          "Access-Control-Allow-Headers":
            "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization",
        }
      });
    } 
    // Handle non-streaming response
    else {
      const result = await handleNonStreamingResponse(difyResponse.body, model, OUTPUT_VARIABLE);
      
      if (result.error) {
        return getResponse(JSON.stringify({ error: result.error }), result.status);
      }
      
      return getResponse(JSON.stringify(result.response), 200);
    }
  } catch (error) {
    console.error("Error:", error.message, error.stack);
    return getResponse(JSON.stringify({
      error: `Error processing request: ${error.message}`
    }), 500);
  }
}

// Register the event listener
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});