#ifdef WIN32
#include "Socket_p.h"

namespace Psc::socket {

Ret<bool> connect(SOCKET s, const Sockaddr_In& addr_in) {
  SOCKADDR_IN addr{};
  addr.sin_family = AF_INET;
  addr.sin_port   = htons(static_cast<u_short>(addr_in.port));

  if (::inet_pton(AF_INET, addr_in.ip.c_str(), &addr.sin_addr) != 1) {
    return unexpected(Enum_Err(NetError::invalid_argument));
  }

  if (::connect(s, reinterpret_cast<const SOCKADDR*>(&addr), sizeof(addr)) == 0) {
    return true; // 立即成功
  }

  const int e = ::WSAGetLastError();

  // 统一按“非阻塞 connect 语义”：这些不算失败
  switch (e) {
  case WSAEWOULDBLOCK:
  case WSAEINPROGRESS:
  case WSAEALREADY:
    return true; // 已发起连接，后续用 SO_ERROR 判定最终结果
  default:
    break;
  }

  return unexpected(Enum_Err(NetErrorCategory::map_system_error(e), e));
}

Ret<void> set_block(Socket_FD that, bool blocking) {
  if (that == -1)
    return Ret<void>();
  u_long mode = blocking ? 0 : 1; // 0 为阻塞, 1 为非阻塞
  if (ioctlsocket(that, FIONBIO, &mode) != 0) {
    LOG_FD_Debug(that, VAR_STR_2(that, blocking) + "设置socket阻塞属性错误!")
  }
  return Ret<void>();
}


NetError NetErrorCategory::map_system_error(int e) noexcept  {
  switch (e) {
  case WSAEINTR:            return NetError::interrupted;
  case WSAECANCELLED:      return NetError::operation_canceled;
  case WSAEINVAL:          return NetError::invalid_argument;
  case WSAEACCES:          return NetError::permission_denied;
  case WSAENOBUFS:         return NetError::resource_exhausted;
  case WSAEBADF:           return NetError::bad_file_descriptor;
  case WSAENOTSOCK:        return NetError::not_a_socket;

  case WSAEWOULDBLOCK:     return NetError::would_block;
  case WSAEINPROGRESS:     return NetError::in_progress;
  case WSAEALREADY:        return NetError::already_in_progress;

  case WSAEADDRINUSE:      return NetError::address_in_use;
  case WSAEADDRNOTAVAIL:   return NetError::address_not_available;
  case WSAENETDOWN:        return NetError::network_down;
  case WSAENETUNREACH:     return NetError::network_unreachable;
  case WSAEHOSTUNREACH:    return NetError::host_unreachable;

  case WSAENOTCONN:        return NetError::not_connected;
  case WSAEISCONN:         return NetError::already_connected;
  case WSAECONNREFUSED:    return NetError::connection_refused;
  case WSAECONNRESET:      return NetError::connection_reset;
  case WSAECONNABORTED:    return NetError::connection_aborted;
  case WSAETIMEDOUT:       return NetError::timed_out;

  default:                 return NetError::unknown_error;
  }
}

ERROR_CODE_TYPE last_socket_ec() {
  int wsa = ::WSAGetLastError();
  return wsa;
}

namespace TCP {
Ret<std::optional<Accept_Info>> accept(SOCKET listen_fd) {
  SOCKADDR_IN clientAddr{};
  int clientAddrSize = sizeof(clientAddr);

  SOCKET client_fd =
      ::accept(listen_fd, reinterpret_cast<SOCKADDR*>(&clientAddr), &clientAddrSize);

  if (client_fd == INVALID_SOCKET) {
    int e = ::WSAGetLastError();

    if (e == WSAEWOULDBLOCK || e == WSAEINTR) {
      return std::nullopt;
    }

    const auto ne = NetErrorCategory::map_system_error(e);
    LOG_FD_Debug(listen_fd, std::string("accept error: ") + std::system_category().message(e));
    return unexpected(Enum_Err(ne, e));
  }

  Accept_Info info{};
  info.fd = client_fd;

  char ipbuf[INET_ADDRSTRLEN]{};
  if (::inet_ntop(AF_INET, &clientAddr.sin_addr, ipbuf, sizeof(ipbuf)) == nullptr) {
    int e = ::WSAGetLastError();
    const auto ne = NetErrorCategory::map_system_error(e);
    LOG_FD_Debug(listen_fd, std::string("inet_ntop error: ") + std::system_category().message(e));
    return unexpected(Enum_Err(ne, e));
  }

  info.sockaddr.ip = ipbuf;
  info.sockaddr.port = ntohs(clientAddr.sin_port);
  return info;
}
}


Ret<std::string> recv_all(SOCKET fd) {
  u_long avail = 0;
  if (::ioctlsocket(fd, FIONREAD, &avail) != 0) {
    int e = ::WSAGetLastError();
    return unexpected(Enum_Err(NetErrorCategory::map_system_error(e), e));
  }

  if (avail == 0) {
    // 无法仅靠 FIONREAD 区分“没数据”还是“已关闭但没数据”
    // 如果你需要区分：可用 select 读集合 + 再 recv(1字节, MSG_PEEK)
    return std::string{};
  }

  size_t to_read = avail;

  std::string buf;
  buf.resize(to_read);

  size_t total = 0;
  while (total < to_read) {
    int n = ::recv(fd, buf.data() + total, (int)(to_read - total), 0);
    if (n == SOCKET_ERROR) {
      int e = ::WSAGetLastError();
      // 理论上 FIONREAD>0 后不该 WSAEWOULDBLOCK，但并发/竞态下可能发生
      if (e == WSAEWOULDBLOCK || e == WSAEINTR) {
        break; // 立刻返回已读部分
      }
      buf.resize(total);
      return unexpected(Enum_Err(NetErrorCategory::map_system_error(e), e));
    }
    if (n == 0) {
      // 对端关闭
      buf.resize(total);
      if (!buf.empty()) return buf;
      return unexpected(Enum_Err(NetError::connection_closed));
    }
    total += (size_t)n;
  }

  buf.resize(total);

  //std::cout << "bufsize:" << buf.size() << std::endl;
  return buf;
}



Ret<std::string> recv_once(Socket_FD fd, int max_bytes) {
  if (max_bytes <= 0) return unexpected(Enum_Err(NetError::invalid_argument));

  std::string buf;
  buf.resize((size_t)max_bytes);

  int n = ::recv(fd, buf.data(), max_bytes, 0);

  if (n == SOCKET_ERROR) {
    int e = ::WSAGetLastError();
    if (e == WSAEWOULDBLOCK || e == WSAEINTR) return std::string{};
    return unexpected(Enum_Err(NetErrorCategory::map_system_error(e), e));
  }
  if (n == 0) return unexpected(Enum_Err(NetError::connection_closed));

  buf.resize((size_t)n);
  return buf;
}



Ret<std::string> recv_all_until_idle(
    Socket_FD fd,
    int chunk_size,
    size_t max_bytes,
    int idle_timeout_ms,   // 多久没新数据就退出
    bool eof_is_ok = true         // n==0 是否当作正常结束
) {
  if (chunk_size <= 0 || max_bytes == 0) {
    return unexpected(Enum_Err(NetError::invalid_argument));
  }

  std::string buffer;
  buffer.reserve(std::min<size_t>(max_bytes, 64 * 1024));

  size_t total = 0;

  while (total < max_bytes) {
    // 用 select 等待可读（避免阻塞卡死；也给 idle 超时提供退出点）
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(fd, &rfds);

    TIMEVAL tv;
    tv.tv_sec  = idle_timeout_ms / 1000;
    tv.tv_usec = (idle_timeout_ms % 1000) * 1000;

    int s = ::select(0, &rfds, nullptr, nullptr, &tv);
    if (s == 0) {
      // 超时：认为“暂时读不到了”，退出返回已读
      return buffer;
    }
    if (s == SOCKET_ERROR) {
      int e = ::WSAGetLastError();
      return unexpected(Enum_Err(NetErrorCategory::map_system_error(e), e));
    }

    const int want = (int)std::min<size_t>((size_t)chunk_size, max_bytes - total);
    buffer.resize(total + (size_t)want);

    int n = ::recv(fd, buffer.data() + total, want, 0);

    if (n == SOCKET_ERROR) {
      int e = ::WSAGetLastError();
      if (e == WSAEWOULDBLOCK || e == WSAEINTR) {
        buffer.resize(total);
        return buffer;
      }
      buffer.resize(total);
      return unexpected(Enum_Err(NetErrorCategory::map_system_error(e), e));
    }

    if (n == 0) {
      buffer.resize(total);
      if (eof_is_ok) return buffer;
      return unexpected(Enum_Err(NetError::connection_closed));
    }

    total += (size_t)n;
    buffer.resize(total);
  }

  // 达到上限：防止对端一直发导致无限读
  return buffer;
}


bool is_client_need_close_ec(ERROR_CODE_TYPE e) {
    switch (e) {
      // 连接已失效/不再可用：应关闭
    case WSAECONNRESET:     // 对端复位
    case WSAECONNABORTED:   // 连接被中止
    case WSAENOTCONN:       // 未连接
    case WSAETIMEDOUT:      // 超时（可视为应关闭）
    case WSAESHUTDOWN:      // 本端已 shutdown，收发被禁止
      return true;

      // 连接拒绝通常发生在 connect 阶段；服务端 recv 上很少见。
      // 这里按你原逻辑，仍视为应关闭（等价于“不可用”）。
    case WSAECONNREFUSED:
      return true;

      // 非阻塞无数据/暂态：不关闭
    case WSAEWOULDBLOCK:
    case WSAEINPROGRESS:
    case WSAEALREADY:
    case WSAEINTR:
      return false;

      // 其他错误：保守策略，不直接关闭（也可改成 true 更激进）
    default:
      return false;
    }
  }




bool is_client_need_close(SOCKET s) {
  char buf[1];
  int r = ::recv(s, buf, sizeof(buf), MSG_PEEK);
  if (r == 0) {
    // 对端正常关闭（FIN/EOF）
    return true;
  }
  if (r == SOCKET_ERROR) {
    const int e = ::WSAGetLastError();
    return Psc::socket::is_client_need_close_ec(e);
  }
  // r > 0：还能读到数据，连接正常
  return false;
}

bool is_needed_reconnect_ec(ERROR_CODE_TYPE e) {
  switch (e) {
    // 这些表示连接已失效/网络不可达：建议重连
  case WSAECONNRESET:     // 远端强制关闭
  case WSAECONNABORTED:   // 连接被中止
  case WSAENOTCONN:       // 未连接
  case WSAETIMEDOUT:      // 超时
  case WSAENETDOWN:       // 网络子系统不可用
  case WSAENETUNREACH:    // 网络不可达
  case WSAEHOSTUNREACH:   // 主机不可达
  case WSAECONNREFUSED:   // 连接被拒绝（多见于 connect 阶段；这里出现也可视为需重连）
    return true;

    // 这些表示“现在没数据/可重试/被打断”：不重连
  case WSAEWOULDBLOCK:    // 非阻塞暂时无数据
  case WSAEINPROGRESS:    // 操作进行中
  case WSAEALREADY:       // 已在进行
  case WSAEINTR:          // 被中断
    return false;

    // 其他错误：按你的策略决定。这里保守处理为“不重连”
  default:
    return false;
  }
}

bool is_needed_reconnect(SOCKET s) {
  char buf[1];
  int r = ::recv(s, buf, sizeof(buf), MSG_PEEK);

  if (r == 0) {
    // 对端正常关闭（FIN/EOF）
    return true;
  }

  if (r == SOCKET_ERROR) {
    const int e = ::WSAGetLastError();
    return is_needed_reconnect_ec(e);
  }

  // r > 0：能窥探到数据，连接仍然活着
  return false;
}

namespace UDP {

Ret<std::string> recvfrom(SOCKET receive_fd, Sockaddr_In* ret, int chunk_size) {
  if (chunk_size <= 0 || ret == nullptr) {
    return unexpected(Enum_Err(NetError::invalid_argument));
  }

  std::string buffer;
  buffer.resize(static_cast<size_t>(chunk_size));

  SOCKADDR_IN client_addr{};
  int addr_len = sizeof(client_addr);

  int n = ::recvfrom(receive_fd,
                     buffer.data(),
                     chunk_size,
                     0,
                     reinterpret_cast<SOCKADDR*>(&client_addr),
                     &addr_len);

  if (n == SOCKET_ERROR) {
    const int e = ::WSAGetLastError();

    // 非阻塞：暂时无数据 / 被中断：维持你原来的语义，返回空串
    if (e == WSAEWOULDBLOCK || e == WSAEINTR) {
      return std::string{};
    }

    const auto ne = NetErrorCategory::map_system_error(e);
    LOG_FD_Debug(receive_fd, std::string("recvfrom error: ") +
                               std::system_category().message(e));
    return unexpected(Enum_Err(ne, e));
  }

  // n == 0：UDP 允许 0 长度 datagram，依然需要填来源地址

  char client_ip[INET_ADDRSTRLEN]{};
  if (::inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, INET_ADDRSTRLEN) == nullptr) {
    const int e = ::WSAGetLastError();
    const auto ne = NetErrorCategory::map_system_error(e);
    LOG_FD_Debug(receive_fd, std::string("inet_ntop error: ") +
                               std::system_category().message(e));
    return unexpected(Enum_Err(ne, e));
  }

  ret->ip = client_ip;
  ret->port = ntohs(client_addr.sin_port);

  buffer.resize(static_cast<size_t>(n));
  return buffer;
}
}

} // namespace Psc::socket
#endif