defmodule ExCurl.Request do
  @moduledoc false
  use Zig,
    otp_app: :ex_curl,
    c: [link_lib: {:system, "curl"}],
    nifs: [request: [], request_dirty_cpu: [:dirty_cpu]]

  ~Z"""
  const beam = @import("beam");
  const std = @import("std");
  const cURL = @cImport({
      @cInclude("curl/curl.h");
  });

  pub const Header = struct { key: []u8, value: []u8 };

  pub const RequestFlags = struct {
      follow_location: bool,
      ssl_verifyhost: bool,
      ssl_verifypeer: bool,
      return_metrics: bool,
      verbose: bool,
      http_auth_negotiate: bool,
  };

  pub const RequestConfiguration = struct {
      headers: []Header,
      url: []u8,
      method: []u8,
      body: []u8,
      flags: RequestFlags,
  };

  pub const ResponseMetrics = struct {
      namelookup_time: f64,
      connect_time: f64,
      appconnect_time: f64,
      pretransfer_time: f64,
      starttransfer_time: f64,
      total_time: f64,
  };

  pub const Response = struct {
      body: []u8,
      status_code: u64,
      headers: []u8,
      metrics: ?ResponseMetrics,
  };

  pub fn request_dirty_cpu(config: RequestConfiguration) !beam.term {
      return request(config);
  }

  pub fn request(config: RequestConfiguration) !beam.term {
      // initialize curl and vars
      var arena_state = std.heap.ArenaAllocator.init(std.heap.c_allocator);
      defer arena_state.deinit();

      const allocator = arena_state.allocator();

      const handle = cURL.curl_easy_init() orelse return beam.make_error_pair("init_failed", .{});
      defer cURL.curl_easy_cleanup(handle);

      var response_buffer = std.ArrayList(u8).init(allocator);
      var headers_buffer = std.ArrayList(u8).init(allocator);

      // superfluous when using an arena allocator, but
      // important if the allocator implementation changes
      defer response_buffer.deinit();
      defer headers_buffer.deinit();

      // set curl opts & callbacks
      try setCurlOpts(allocator, handle, config);
      // set headers
      var header_slist: [*c]cURL.curl_slist = null;
      defer cURL.curl_slist_free_all(header_slist);
      for (config.headers) |header| {
          const buf = try allocator.alloc(u8, header.key.len + 3 + header.value.len);
          _ = try std.fmt.bufPrint(buf, "{s}: {s}\x00", .{ header.key, header.value });
          header_slist = cURL.curl_slist_append(header_slist, buf.ptr);
          allocator.free(buf);
      }

      // Response body callback
      if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_HTTPHEADER, header_slist) != cURL.CURLE_OK)
          unreachable;

      // Response body callback
      if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_WRITEFUNCTION, writeToArrayListCallback) != cURL.CURLE_OK)
          unreachable;
      if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_WRITEDATA, &response_buffer) != cURL.CURLE_OK)
          unreachable;

      // Headers callback
      if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_HEADERFUNCTION, writeToArrayListCallback) != cURL.CURLE_OK)
          unreachable;
      if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_HEADERDATA, &headers_buffer) != cURL.CURLE_OK)
          unreachable;

      // Request body
      if (!std.mem.eql(u8, config.body, "")) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_READFUNCTION, readFn) != cURL.CURLE_OK)
              unreachable;
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_READDATA, &config) != cURL.CURLE_OK)
              unreachable;
      }

      // 3. perform request
      const result = cURL.curl_easy_perform(handle);
      if (result != cURL.CURLE_OK)
          return beam.make_error_pair(result, .{});

      // 4. getinfo and create response
      const response = try makeResponse(handle, response_buffer, headers_buffer, config);
      return beam.make(.{ .ok, response }, .{});
  }

  fn makeResponse(handle: *cURL.CURL, response_buffer: std.ArrayList(u8), headers_buffer: std.ArrayList(u8), config: RequestConfiguration) !Response {
      var status_code: u64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_RESPONSE_CODE, &status_code) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      return .{
          .body = response_buffer.items,
          .status_code = status_code,
          .headers = headers_buffer.items,
          .metrics = if (config.flags.return_metrics) try makeResponseMetrics(handle) else null,
      };
  }

  fn makeResponseMetrics(handle: *cURL.CURL) !ResponseMetrics {
      var total_time: f64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_TOTAL_TIME_T, &total_time) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      var namelookup_time: f64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_NAMELOOKUP_TIME_T, &namelookup_time) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      var connect_time: f64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_CONNECT_TIME_T, &connect_time) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      var appconnect_time: f64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_APPCONNECT_TIME_T, &appconnect_time) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      var pretransfer_time: f64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_PRETRANSFER_TIME_T, &pretransfer_time) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      var starttransfer_time: f64 = 0;
      if (cURL.curl_easy_getinfo(handle, cURL.CURLINFO_STARTTRANSFER_TIME_T, &starttransfer_time) != cURL.CURLE_OK)
          return error.CURLGETINFO_FAILED;

      return .{
          .namelookup_time = namelookup_time,
          .connect_time = connect_time,
          .appconnect_time = appconnect_time,
          .pretransfer_time = pretransfer_time,
          .starttransfer_time = starttransfer_time,
          .total_time = total_time,
      };
  }

  fn setCurlOpts(allocator: std.mem.Allocator, handle: *cURL.CURL, config: RequestConfiguration) !void {
      if (config.flags.verbose) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_VERBOSE, @as(c_long, 1)) != cURL.CURLE_OK)
              unreachable;
      }

      if (config.flags.follow_location) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_FOLLOWLOCATION, @as(c_long, 1)) != cURL.CURLE_OK)
              unreachable;
      }

      if (config.flags.ssl_verifypeer) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_SSL_VERIFYPEER, @as(c_long, 1)) != cURL.CURLE_OK)
              unreachable;
      } else {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_SSL_VERIFYPEER, @as(c_long, 0)) != cURL.CURLE_OK)
              unreachable;
      }

      if (config.flags.ssl_verifyhost) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_SSL_VERIFYHOST, @as(c_long, 1)) != cURL.CURLE_OK)
              unreachable;
      } else {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_SSL_VERIFYHOST, @as(c_long, 0)) != cURL.CURLE_OK)
              unreachable;
      }

      // Set options to support RFC 4559 for SPNEGO-based Kerberos authentication
      // when this flag is enabled
      if (config.flags.http_auth_negotiate) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_HTTPAUTH, cURL.CURLAUTH_NEGOTIATE) != cURL.CURLE_OK)
              unreachable;
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_USERPWD, ":") != cURL.CURLE_OK)
              unreachable;
      }

      // HTTP Method
      if (std.mem.eql(u8, config.method, "POST")) {
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_POST, @as(c_long, 1)) != cURL.CURLE_OK)
              unreachable;
      } else if (!std.mem.eql(u8, config.method, "GET")) {
          const method_as_c_string = allocator.dupeZ(u8, config.method) catch unreachable;
          defer allocator.free(method_as_c_string);
          if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_CUSTOMREQUEST, method_as_c_string.ptr) != cURL.CURLE_OK)
              unreachable;
      }

      // URL
      const url_as_c_string = allocator.dupeZ(u8, config.url) catch unreachable;
      defer allocator.free(url_as_c_string);
      if (cURL.curl_easy_setopt(handle, cURL.CURLOPT_URL, url_as_c_string.ptr) != cURL.CURLE_OK)
          unreachable;
  }

  fn readFn(dest: [*c]u8, size: usize, nmemb: usize, config: *RequestConfiguration) callconv(.C) usize {
      const bufferSize = size * nmemb;

      if (config.body.len == 0) {
          return 0; // nothing to read
      }

      const n = @min(config.body.len, bufferSize);
      std.mem.copyForwards(u8, dest[0..n], config.body[0..n]);
      config.body = config.body[n..];
      return n;
  }

  fn writeToArrayListCallback(data: *anyopaque, size: c_uint, nmemb: c_uint, user_data: *anyopaque) callconv(.C) c_uint {
      var buffer: *std.ArrayList(u8) = @alignCast(@ptrCast(user_data));
      var typed_data: [*]u8 = @ptrCast(data);
      buffer.appendSlice(typed_data[0 .. nmemb * size]) catch return 0;
      return nmemb * size;
  }
  """
end