import { envy, strConv, assert } from "@tsxo/envy";

// Required values.
// Required will trim the string and assert a minimum length of one.
const apiKey = envy.required("API_KEY").assert(assert.minLen(32)).build();

// Optional values with defaults.
// Required will trim the string and assert a minimum length of one.
const region = envy
    .optional("AWS_REGION", "us-east-1")
    .assert(assert.prefix("us-"))
    .build();

// Number conversion.
const port = envy.number("PORT", 3000).assert(assert.isPort()).build();

// Boolean conversion.
// Recognises the following values as `true`: "true", "yes", "1", "on".
// Recognises the following values as `false`: "false", "no", "0", "off".
const debug = envy.bool("DEBUG", false).build();

// Array parsing (comma-separated by default).
const whitelist = envy
    .array("IP_WHITELIST", ["127.0.0.1"])
    .assert(assert.minLen(1))
    .build();

// Manual conversion, transformation, and validation.
const manual = envy
    .optional("MANUAL", "42")
    .transform(s => s.trim())
    .assert(s => s.length() > 0, "Must have a length greater than zero")
    .convert(strConv.toNumber()) // You can use whichever method of conversion here.
    .build();

// Type narrowing.
type Region = "us-east-1" | "us-west-2";

function isRegion(val: string): val is Region {
    return val === "us-east-1" || val === "us-west-2";
}

const region = envy
    .required("AWS_REGION")
    .narrow(isRegion, "Invalid AWS region")
    .build(); // region is now typed as Region rather than string.

/**
 * Assertion function type that validates a value and provides metadata.
 */
type AssertFn<T> = {
    (v: T): boolean;
    context?: FnCtx;
};

/**
 * Function type for narrowing a value from type T to a more specific type N.
 */
type NarrowFn<T, N extends T> = (v: T) => v is N;

/**
 * Transform function for modifying values while maintaining their type.
 */
type TransformFn<T> = (v: T) => T;

/**
 * Conversion function for changing value types.
 */
type ConvertFn<In, Out> = (v: In) => Out;

/**
 * Function metadata context for debugging and error handling.
 */
type FnCtx = {
    description: string;
    [key: string]: unknown;
};

/**
 * Error context with detailed information about failures.
 */
type ErrCtx = {
    description?: string;
    key?: string;
    value?: unknown;
    [key: string]: unknown;
};

// Exact length.
const key = envy.required("API_KEY").assert(assert.len(32)).build();

// Minimum length.
const password = envy.required("DB_PASSWORD").assert(assert.minLen(8)).build();

// Maximum length.
const username = envy.required("DB_USER").assert(assert.maxLen(20)).build();

// Prefix validation.
const bucket = envy.required("S3_BUCKET").assert(assert.prefix("app-")).build();

// Suffix validation.
const logFile = envy.required("LOG_FILE").assert(assert.suffix(".log")).build();

// Substring check.
const dbUrl = envy
    .required("DATABASE_URL")
    .assert(assert.substring("postgres://"))
    .build();

// Regex matching.
const email = envy
    .required("ADMIN_EMAIL")
    .assert(assert.matches(/^admin-/)) // Ensure email starts with "admin-"
    .build();

// URL validation with protocol restrictions.
const apiEndpoint = envy
    .required("API_ENDPOINT")
    .assert(assert.isURL(["https:"]))
    .build();

// Port number validation.
const serverPort = envy.number("SERVER_PORT").assert(assert.isPort()).build();

// Restricted value set.
const logLevel = envy
    .required("LOG_LEVEL")
    .assert(assert.options(["debug", "info", "warn", "error"]))
    .build();

// Custom port range validator.
const isServicePort = assert.create(
    (value: number) => value >= 1024 && value <= 49151,
    {
        description: "Must be a valid service port number",
        min: 1024,
        max: 49151,
    },
);

// Custom semantic version validator.
const isSemVer = assert.create(
    (value: string) => /^\d+\.\d+\.\d+$/.test(value),
    {
        description: "Must be a semantic version (x.y.z)",
        format: "semantic version",
        example: "1.0.0",
    },
);

// Usage
const servicePort = envy.number("SERVICE_PORT").assert(isServicePort()).build();

const version = envy.required("APP_VERSION").assert(isSemVer()).build();

// Simple inline assertion with custom error message
const username = envy
    .required("USERNAME")
    .assert(
        val => val.length >= 3 && val.length <= 20,
        "Username must be between 3 and 20 characters",
    )
    .build();

// Combining inline and custom assertions
const databaseUrl = envy
    .required("DATABASE_URL")
    .assert(assert.isURL(["postgres:"])) // Built-in assertion
    .assert(
        // Inline assertion
        url => url.includes("@") && url.includes("/"),
        "Database URL must include credentials and database name",
    )
    .build();