/*
 * Minimal libpgport/libpgcommon stubs for V's `db.pg` cross compilation to
 * Linux. The bundled `linuxroot` sysroot ships a static `libpq.a` but no
 * `libpgcommon.a` / `libpgport.a`, so a number of symbols referenced by
 * libpq stay unresolved at link time. The implementations here cover only
 * the entry points actually referenced by the libpq.a frontend (verified
 * via `ld.lld --error-limit=0`), forwarding to libc / OpenSSL equivalents.
 * They are NOT a full replacement for libpgport / libpgcommon: SASLprep
 * is a no-op, encoding tables only know the name list, etc. Enough to
 * connect to a Postgres server using SCRAM-SHA-256 and exchange queries
 * in SQL_ASCII / UTF8.
 *
 * Linked only via `$if cross_compile ? && linux` in vlib/db/pg/pg.c.v.
 * The linuxroot sysroot lacks some POSIX headers (e.g. pwd.h), so the few
 * libc entry points used here are declared inline instead of pulled from
 * system headers.
 */

#define _GNU_SOURCE
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <fcntl.h>

/* Forward declarations to avoid relying on headers the linuxroot sysroot
 * doesn't ship (pwd.h, full netdb.h getaddrinfo/getnameinfo prototypes,
 * sys/un.h ucred). */
struct passwd;
struct addrinfo;
struct sockaddr;

extern int getpwuid_r(unsigned int uid, struct passwd *pwd, char *buf,
                      size_t buflen, struct passwd **result);
extern int getaddrinfo(const char *node, const char *service,
                       const struct addrinfo *hints, struct addrinfo **res);
extern void freeaddrinfo(struct addrinfo *res);
extern int getnameinfo(const struct sockaddr *sa, unsigned int salen, char *host,
                       unsigned int hostlen, char *serv, unsigned int servlen,
                       int flags);
extern const char *inet_ntop(int af, const void *src, char *dst, unsigned int size);

/* OpenSSL — already linked via -lssl -lcrypto. We declare what we need so we
 * don't depend on <openssl/*.h> being on the include search path. */
typedef struct evp_md_st EVP_MD;
typedef struct hmac_ctx_st HMAC_CTX;
typedef struct engine_st ENGINE;
extern const EVP_MD *EVP_sha224(void);
extern const EVP_MD *EVP_sha256(void);
extern const EVP_MD *EVP_sha384(void);
extern const EVP_MD *EVP_sha512(void);
extern const EVP_MD *EVP_md5(void);
extern const EVP_MD *EVP_sha1(void);
extern HMAC_CTX *HMAC_CTX_new(void);
extern void HMAC_CTX_free(HMAC_CTX *ctx);
extern int HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len,
                        const EVP_MD *md, ENGINE *impl);
extern int HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len);
extern int HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len);
extern int RAND_bytes(unsigned char *buf, int num);

size_t strlcpy(char *dst, const char *src, size_t siz) {
	const char *s = src;
	size_t n = siz;
	if (n != 0) {
		while (--n != 0) {
			if ((*dst++ = *s++) == '\0') {
				break;
			}
		}
	}
	if (n == 0) {
		if (siz != 0) {
			*dst = '\0';
		}
		while (*s++) {
		}
	}
	return (size_t)(s - src - 1);
}

int pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
	return vsnprintf(str, count, fmt, args);
}

int pg_snprintf(char *str, size_t count, const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	int n = vsnprintf(str, count, fmt, ap);
	va_end(ap);
	return n;
}

int pg_sprintf(char *str, const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	int n = vsprintf(str, fmt, ap);
	va_end(ap);
	return n;
}

int pg_vfprintf(FILE *stream, const char *fmt, va_list args) {
	return vfprintf(stream, fmt, args);
}

int pg_fprintf(FILE *stream, const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	int n = vfprintf(stream, fmt, ap);
	va_end(ap);
	return n;
}

int pg_printf(const char *fmt, ...) {
	va_list ap;
	va_start(ap, fmt);
	int n = vprintf(fmt, ap);
	va_end(ap);
	return n;
}

int pg_strcasecmp(const char *s1, const char *s2) {
	return strcasecmp(s1, s2);
}

int pg_strncasecmp(const char *s1, const char *s2, size_t n) {
	return strncasecmp(s1, s2, n);
}

unsigned char pg_tolower(unsigned char ch) {
	if (ch >= 'A' && ch <= 'Z') {
		return ch + ('a' - 'A');
	}
	return ch;
}

unsigned char pg_toupper(unsigned char ch) {
	if (ch >= 'a' && ch <= 'z') {
		return ch - ('a' - 'A');
	}
	return ch;
}

int pg_strip_crlf(char *str) {
	int len = (int)strlen(str);
	while (len > 0 && (str[len - 1] == '\n' || str[len - 1] == '\r')) {
		str[--len] = '\0';
	}
	return len;
}

char *pg_strerror_r(int errnum, char *buf, size_t buflen) {
	const char *s = strerror(errnum);
	if (s == NULL) {
		snprintf(buf, buflen, "errno %d", errnum);
	} else {
		strncpy(buf, s, buflen);
		if (buflen > 0) {
			buf[buflen - 1] = '\0';
		}
	}
	return buf;
}

int pqGetpwuid(unsigned int uid, struct passwd *resbuf, char *buf, size_t buflen,
               struct passwd **result) {
	return getpwuid_r(uid, resbuf, buf, buflen, result);
}

int pg_getaddrinfo_all(const char *hostname, const char *servname,
                       const struct addrinfo *hint, struct addrinfo **result) {
	return getaddrinfo(hostname, servname, hint, result);
}

void pg_freeaddrinfo_all(int hint_ai_family, struct addrinfo *ai) {
	(void)hint_ai_family;
	if (ai != NULL) {
		freeaddrinfo(ai);
	}
}

int pg_getnameinfo_all(const void *addr, int salen, char *node, size_t nodelen,
                       char *service, size_t servicelen, int flags) {
	return getnameinfo((const struct sockaddr *)addr, (unsigned int)salen, node,
	                   (unsigned int)nodelen, service, (unsigned int)servicelen,
	                   flags);
}

int pg_set_noblock(int sock) {
	int flags = fcntl(sock, F_GETFL);
	if (flags < 0) {
		return 0;
	}
	if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
		return 0;
	}
	return 1;
}

/* Linux-only: getpeereid via SO_PEERCRED. */
struct pg_ucred_compat { unsigned int pid; unsigned int uid; unsigned int gid; };
#ifndef SO_PEERCRED
#define SO_PEERCRED 17
#endif

int getpeereid(int sock, unsigned int *euid, unsigned int *egid) {
	struct pg_ucred_compat cred;
	unsigned int len = sizeof(cred);
	if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &cred, &len) < 0) {
		return -1;
	}
	if (euid != NULL) {
		*euid = cred.uid;
	}
	if (egid != NULL) {
		*egid = cred.gid;
	}
	return 0;
}

const char *pg_inet_net_ntop(int af, const void *src, int bits, char *dst,
                             size_t size) {
	(void)bits;
	return inet_ntop(af, src, dst, (unsigned int)size);
}

/* SASLprep: a real implementation normalizes Unicode per RFC 4013. The
 * frontend uses it on passwords before SCRAM hashing; if we just pass the
 * raw bytes through, ASCII-only passwords still hash to the same value as
 * any compliant client would produce. Non-ASCII passwords may fail to
 * authenticate. PG_SASLPREP_SUCCESS == 0 in PostgreSQL. */
int pg_saslprep(const char *input, char **output) {
	size_t n = strlen(input);
	char *copy = (char *)malloc(n + 1);
	if (copy == NULL) {
		return -1; /* PG_SASLPREP_OOM */
	}
	memcpy(copy, input, n + 1);
	*output = copy;
	return 0;
}

int pg_strong_random(void *buf, size_t len) {
	if (RAND_bytes((unsigned char *)buf, (int)len) == 1) {
		return 1;
	}
	return 0;
}

/* Base64 codec: standard alphabet, identical layout to PostgreSQL's
 * src/common/base64.c so libpq's helpers (which expect specific overflow
 * semantics) behave the same. */
static const char b64_alphabet[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

static const signed char b64_lookup[256] = {
    [0 ... 255] = -1,
    ['A'] = 0,  ['B'] = 1,  ['C'] = 2,  ['D'] = 3,  ['E'] = 4,  ['F'] = 5,
    ['G'] = 6,  ['H'] = 7,  ['I'] = 8,  ['J'] = 9,  ['K'] = 10, ['L'] = 11,
    ['M'] = 12, ['N'] = 13, ['O'] = 14, ['P'] = 15, ['Q'] = 16, ['R'] = 17,
    ['S'] = 18, ['T'] = 19, ['U'] = 20, ['V'] = 21, ['W'] = 22, ['X'] = 23,
    ['Y'] = 24, ['Z'] = 25, ['a'] = 26, ['b'] = 27, ['c'] = 28, ['d'] = 29,
    ['e'] = 30, ['f'] = 31, ['g'] = 32, ['h'] = 33, ['i'] = 34, ['j'] = 35,
    ['k'] = 36, ['l'] = 37, ['m'] = 38, ['n'] = 39, ['o'] = 40, ['p'] = 41,
    ['q'] = 42, ['r'] = 43, ['s'] = 44, ['t'] = 45, ['u'] = 46, ['v'] = 47,
    ['w'] = 48, ['x'] = 49, ['y'] = 50, ['z'] = 51, ['0'] = 52, ['1'] = 53,
    ['2'] = 54, ['3'] = 55, ['4'] = 56, ['5'] = 57, ['6'] = 58, ['7'] = 59,
    ['8'] = 60, ['9'] = 61, ['+'] = 62, ['/'] = 63,
};

int pg_b64_enc_len(int srclen) {
	return ((srclen + 2) / 3) * 4;
}

int pg_b64_dec_len(int srclen) {
	return (srclen / 4) * 3;
}

int pg_b64_encode(const char *src, int len, char *dst, int dstlen) {
	int i = 0, j = 0;
	while (i < len) {
		unsigned int b0 = (unsigned char)src[i++];
		unsigned int b1 = (i < len) ? (unsigned char)src[i++] : 0;
		unsigned int b2 = (i < len) ? (unsigned char)src[i++] : 0;
		int rem = (i > len) ? (i - len) : 0;
		if (j + 4 > dstlen) {
			return -1;
		}
		dst[j++] = b64_alphabet[b0 >> 2];
		dst[j++] = b64_alphabet[((b0 & 0x03) << 4) | (b1 >> 4)];
		dst[j++] = (rem >= 2) ? '=' : b64_alphabet[((b1 & 0x0f) << 2) | (b2 >> 6)];
		dst[j++] = (rem >= 1) ? '=' : b64_alphabet[b2 & 0x3f];
	}
	return j;
}

int pg_b64_decode(const char *src, int len, char *dst, int dstlen) {
	int i = 0, j = 0;
	while (i < len) {
		while (i < len && (src[i] == '\n' || src[i] == '\r' || src[i] == ' ' ||
		                   src[i] == '\t')) {
			i++;
		}
		if (i >= len) {
			break;
		}
		signed char c0 = b64_lookup[(unsigned char)src[i++]];
		if (c0 < 0) {
			return -1;
		}
		while (i < len && (src[i] == '\n' || src[i] == '\r' || src[i] == ' ' ||
		                   src[i] == '\t')) {
			i++;
		}
		if (i >= len) {
			return -1;
		}
		signed char c1 = b64_lookup[(unsigned char)src[i++]];
		if (c1 < 0) {
			return -1;
		}
		while (i < len && (src[i] == '\n' || src[i] == '\r' || src[i] == ' ' ||
		                   src[i] == '\t')) {
			i++;
		}
		signed char c2 = -1, c3 = -1;
		char raw2 = 0, raw3 = 0;
		if (i < len) {
			raw2 = src[i++];
			if (raw2 != '=') {
				c2 = b64_lookup[(unsigned char)raw2];
				if (c2 < 0) {
					return -1;
				}
			}
		}
		while (i < len && (src[i] == '\n' || src[i] == '\r' || src[i] == ' ' ||
		                   src[i] == '\t')) {
			i++;
		}
		if (i < len) {
			raw3 = src[i++];
			if (raw3 != '=') {
				c3 = b64_lookup[(unsigned char)raw3];
				if (c3 < 0) {
					return -1;
				}
			}
		}
		if (j >= dstlen) {
			return -1;
		}
		dst[j++] = (char)((c0 << 2) | ((c1 & 0x30) >> 4));
		if (raw2 == '=') {
			break;
		}
		if (j >= dstlen) {
			return -1;
		}
		dst[j++] = (char)(((c1 & 0x0f) << 4) | ((c2 & 0x3c) >> 2));
		if (raw3 == '=') {
			break;
		}
		if (j >= dstlen) {
			return -1;
		}
		dst[j++] = (char)(((c2 & 0x03) << 6) | c3);
	}
	return j;
}

/* pg_hmac: thin wrapper over OpenSSL HMAC_CTX. PG's pg_cryptohash_type:
 *   0 PG_MD5, 1 PG_SHA1, 2 PG_SHA224, 3 PG_SHA256, 4 PG_SHA384, 5 PG_SHA512 */
struct pg_hmac_ctx {
	HMAC_CTX *ctx;
	const EVP_MD *md;
	int type;
	int error;
};

struct pg_hmac_ctx *pg_hmac_create(int type) {
	const EVP_MD *md = NULL;
	switch (type) {
	case 0: md = EVP_md5(); break;
	case 1: md = EVP_sha1(); break;
	case 2: md = EVP_sha224(); break;
	case 3: md = EVP_sha256(); break;
	case 4: md = EVP_sha384(); break;
	case 5: md = EVP_sha512(); break;
	default: return NULL;
	}
	if (md == NULL) {
		return NULL;
	}
	struct pg_hmac_ctx *c = (struct pg_hmac_ctx *)malloc(sizeof(*c));
	if (c == NULL) {
		return NULL;
	}
	c->md = md;
	c->type = type;
	c->error = 0;
	c->ctx = HMAC_CTX_new();
	if (c->ctx == NULL) {
		free(c);
		return NULL;
	}
	return c;
}

int pg_hmac_init(struct pg_hmac_ctx *ctx, const unsigned char *key, size_t len) {
	if (ctx == NULL) {
		return -1;
	}
	if (HMAC_Init_ex(ctx->ctx, key, (int)len, ctx->md, NULL) != 1) {
		ctx->error = 1;
		return -1;
	}
	return 0;
}

int pg_hmac_update(struct pg_hmac_ctx *ctx, const unsigned char *data, size_t len) {
	if (ctx == NULL) {
		return -1;
	}
	if (HMAC_Update(ctx->ctx, data, len) != 1) {
		ctx->error = 1;
		return -1;
	}
	return 0;
}

int pg_hmac_final(struct pg_hmac_ctx *ctx, unsigned char *dest, size_t len) {
	if (ctx == NULL) {
		return -1;
	}
	unsigned int outlen = (unsigned int)len;
	if (HMAC_Final(ctx->ctx, dest, &outlen) != 1) {
		ctx->error = 1;
		return -1;
	}
	return 0;
}

void pg_hmac_free(struct pg_hmac_ctx *ctx) {
	if (ctx == NULL) {
		return;
	}
	if (ctx->ctx != NULL) {
		HMAC_CTX_free(ctx->ctx);
	}
	free(ctx);
}

const char *pg_hmac_error(struct pg_hmac_ctx *ctx) {
	if (ctx == NULL) {
		return "out of memory";
	}
	if (ctx->error) {
		return "HMAC error";
	}
	return "";
}

/* SCRAM-SHA-256 helpers. Signatures match PG 14 src/common/scram-common.c.
 * SCRAM_KEY_LEN is 32 (SHA-256 output). */
extern int PKCS5_PBKDF2_HMAC(const char *pass, int passlen,
                              const unsigned char *salt, int saltlen, int iter,
                              const EVP_MD *digest, int keylen,
                              unsigned char *out);

static int scram_hmac_one(const unsigned char *key, const char *msg,
                          unsigned char *result, const char **errstr) {
	struct pg_hmac_ctx *ctx = pg_hmac_create(3 /* PG_SHA256 */);
	if (ctx == NULL) {
		if (errstr != NULL) {
			*errstr = "out of memory";
		}
		return -1;
	}
	if (pg_hmac_init(ctx, key, 32) < 0 ||
	    pg_hmac_update(ctx, (const unsigned char *)msg, strlen(msg)) < 0 ||
	    pg_hmac_final(ctx, result, 32) < 0) {
		if (errstr != NULL) {
			*errstr = pg_hmac_error(ctx);
		}
		pg_hmac_free(ctx);
		return -1;
	}
	pg_hmac_free(ctx);
	return 0;
}

int scram_ServerKey(const unsigned char *salted_password, unsigned char *result,
                    const char **errstr) {
	return scram_hmac_one(salted_password, "Server Key", result, errstr);
}

int scram_ClientKey(const unsigned char *salted_password, unsigned char *result,
                    const char **errstr) {
	return scram_hmac_one(salted_password, "Client Key", result, errstr);
}

/* SHA-256 of input → result (32 bytes). */
extern unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
int scram_H(const unsigned char *input, int len, unsigned char *result,
            const char **errstr) {
	if (SHA256(input, (size_t)len, result) == NULL) {
		if (errstr != NULL) {
			*errstr = "SHA256 failed";
		}
		return -1;
	}
	return 0;
}

/* PBKDF2-HMAC-SHA256(password, salt, iterations) → 32-byte salted password. */
int scram_SaltedPassword(const char *password, const char *salt, int saltlen,
                         int iterations, unsigned char *result,
                         const char **errstr) {
	if (PKCS5_PBKDF2_HMAC(password, (int)strlen(password),
	                      (const unsigned char *)salt, saltlen, iterations,
	                      EVP_sha256(), 32, result) != 1) {
		if (errstr != NULL) {
			*errstr = "PBKDF2 failed";
		}
		return -1;
	}
	return 0;
}

/* scram_build_secret is server-side; the archive references it because some
 * objects in libpq.a were compiled with both frontend and backend sections
 * sharing scram-common.c. Provide a stub that returns NULL — the frontend
 * code path that actually calls this would be unreachable. */
char *scram_build_secret(const char *salt, int saltlen, int iterations,
                         const char *password, const char **errstr) {
	(void)salt;
	(void)saltlen;
	(void)iterations;
	(void)password;
	if (errstr != NULL) {
		*errstr = "scram_build_secret not implemented in frontend stubs";
	}
	return NULL;
}

/* pg_md5_encrypt: legacy "md5"-prefixed MD5(password || username) hash. */
extern unsigned char *MD5(const unsigned char *d, size_t n, unsigned char *md);
int pg_md5_encrypt(const char *passwd, const char *salt, size_t salt_len,
                   char *buf) {
	static const char hex[] = "0123456789abcdef";
	size_t passwd_len = strlen(passwd);
	unsigned char digest[16];
	unsigned char *tmp = (unsigned char *)malloc(passwd_len + salt_len);
	if (tmp == NULL) {
		return 0;
	}
	memcpy(tmp, passwd, passwd_len);
	memcpy(tmp + passwd_len, salt, salt_len);
	if (MD5(tmp, passwd_len + salt_len, digest) == NULL) {
		free(tmp);
		return 0;
	}
	free(tmp);
	buf[0] = 'm';
	buf[1] = 'd';
	buf[2] = '5';
	for (int i = 0; i < 16; i++) {
		buf[3 + 2 * i] = hex[digest[i] >> 4];
		buf[3 + 2 * i + 1] = hex[digest[i] & 0x0f];
	}
	buf[35] = '\0';
	return 1;
}

/* Encoding helpers: the linuxroot libpq.a is built without libpgcommon, so the
 * client-side encoding tables are absent. Returning sensible defaults keeps
 * basic libpq usage (connect, query in SQL_ASCII / UTF8) working. */

int pg_get_encoding_from_locale(const char *ctype, int write_message) {
	(void)ctype;
	(void)write_message;
	return -1;
}

static const char *const pg_encoding_names[] = {
	"SQL_ASCII", "EUC_JP", "EUC_CN", "EUC_KR", "EUC_TW", "EUC_JIS_2004",
	"UTF8", "MULE_INTERNAL", "LATIN1", "LATIN2", "LATIN3", "LATIN4", "LATIN5",
	"LATIN6", "LATIN7", "LATIN8", "LATIN9", "LATIN10", "WIN1256", "WIN1258",
	"WIN866", "WIN874", "KOI8R", "WIN1251", "WIN1252", "ISO_8859_5", "ISO_8859_6",
	"ISO_8859_7", "ISO_8859_8", "WIN1250", "WIN1253", "WIN1254", "WIN1255",
	"WIN1257", "KOI8U", "SJIS", "BIG5", "GBK", "UHC", "GB18030", "JOHAB",
	"SHIFT_JIS_2004",
};

const char *pg_encoding_to_char(int encoding) {
	const int n = (int)(sizeof(pg_encoding_names) / sizeof(pg_encoding_names[0]));
	if (encoding < 0 || encoding >= n) {
		return "SQL_ASCII";
	}
	return pg_encoding_names[encoding];
}

int pg_char_to_encoding(const char *name) {
	const int n = (int)(sizeof(pg_encoding_names) / sizeof(pg_encoding_names[0]));
	if (name == NULL) {
		return -1;
	}
	for (int i = 0; i < n; i++) {
		if (strcasecmp(name, pg_encoding_names[i]) == 0) {
			return i;
		}
	}
	return -1;
}

int pg_valid_server_encoding_id(int encoding) {
	return encoding == 0 || encoding == 6;
}

/* Multibyte helpers. Treat SQL_ASCII (0) and UTF8 (6) properly; for other
 * encodings, fall back to UTF8-shaped behaviour. Good enough for libpq's
 * frontend encoding probes, but not a substitute for libpgcommon's tables. */
int pg_encoding_max_length(int encoding) {
	if (encoding == 0 /* SQL_ASCII */) {
		return 1;
	}
	return 4; /* UTF-8 worst case */
}

int pg_encoding_mblen(int encoding, const char *mbstr) {
	unsigned char c = (unsigned char)*mbstr;
	if (encoding == 0 /* SQL_ASCII */) {
		return 1;
	}
	if (c < 0x80) {
		return 1;
	}
	if ((c & 0xe0) == 0xc0) {
		return 2;
	}
	if ((c & 0xf0) == 0xe0) {
		return 3;
	}
	if ((c & 0xf8) == 0xf0) {
		return 4;
	}
	return 1;
}

int pg_encoding_dsplen(int encoding, const char *mbstr) {
	(void)encoding;
	unsigned char c = (unsigned char)*mbstr;
	if (c == 0) {
		return 0;
	}
	if (c < 0x20 || c == 0x7f) {
		return -1; /* control char: caller decides */
	}
	return 1;
}

/* libpgcommon link canary: signals that libpq was linked with the matching
 * libpgcommon flavour. We only have the frontend, so always report frontend. */
int pg_link_canary_is_frontend(void) {
	return 1;
}