/* Aeolipile dry-lab kernel, ABI 100. C11 runtime.
 * Every arithmetic statement of the dispatch loop repeats python/aeo_core.py
 * in the same order. See include/aeo_core.h for the build flag that matters.
 */
#include "../include/aeo_core.h"

#define FNV_OFFSET_64 0xcbf29ce484222325ULL
#define FNV_PRIME_64 0x100000001b3ULL

typedef struct {
    double lo;
    double hi;
    int lo_open;
    int integer;
} CfgRule;

static const CfgRule CFG_RULES[AEO_CFG_N] = {
    {0.0, 1e5, 1, 0},        /* it_load_mw */
    {1.0, 3.0, 0, 0},        /* pue_base */
    {0.0, 0.2, 0, 0},        /* pue_temp_slope */
    {0.0, 1e6, 0, 0},        /* solar_cap_mw */
    {0.0, 1e6, 0, 0},        /* wind_cap_mw */
    {0.0, 1e7, 0, 0},        /* bess_energy_mwh */
    {0.0, 1e6, 0, 0},        /* bess_power_mw */
    {0.0, 1.0, 1, 0},        /* bess_rte */
    {0.0, 0.01, 0, 0},       /* bess_fade_per_efc */
    {0.0, 1e6, 0, 0},        /* gas_cap_mw */
    {3.412142, 30.0, 0, 0},  /* gas_heat_rate_mmbtu_mwh */
    {0.0, 1000.0, 0, 0},     /* gas_price_usd_mmbtu */
    {0.0, 1000.0, 0, 0},     /* gas_vom_usd_mwh */
    {0.0, 1e6, 0, 0},        /* grid_import_cap_mw */
    {0.0, 1.0, 0, 0},        /* forced_curtailment */
    {0.0, 100.0, 0, 0},      /* lmp_multiplier */
    {0.0, 1e7, 0, 0},        /* capex_usd_million */
    {0.0, 1e6, 0, 0},        /* fixed_opex_usd_m_yr */
    {0.0, 0.5, 0, 0},        /* discount_rate */
    {1.0, 100.0, 0, 1},      /* project_years */
    {0.0, 600.0, 0, 1},      /* grid_delay_months */
    {0.0, 1e6, 0, 0},        /* voll_usd_mwh */
    {-1.0, 8759.0, 0, 1},    /* dunkel_start_hour */
    {0.0, 8760.0, 0, 1},     /* dunkel_hours */
    {0.0, 1e5, 0, 0},        /* dunkel_lmp_adder_usd */
    {-1.0, 8759.0, 0, 1},    /* heat_start_hour */
    {0.0, 8760.0, 0, 1},     /* heat_hours */
    {0.0, 40.0, 0, 0},       /* heat_delta_c */
};

static const double SERIES_LO[AEO_SERIES_N] = {0.0, 0.0, -1e4, -90.0};
static const double SERIES_HI[AEO_SERIES_N] = {1.0, 1.0, 1e5, 70.0};

static int is_finite(double v) {
    /* NaN fails v == v; an infinity fails the subtraction. */
    return v == v && (v - v) == 0.0;
}

static uint64_t fnv_double(uint64_t acc, double v) {
    union {
        double d;
        uint64_t u;
    } bits;
    bits.d = v;
    for (int i = 0; i < 8; i++) {
        acc ^= (bits.u >> (8 * i)) & 0xffULL; /* little-endian byte order on any host */
        acc *= FNV_PRIME_64;
    }
    return acc;
}

static double quantize(double x) {
    return __builtin_floor(x * 1e6 + 0.5);
}

uint32_t aeo_abi_version(void) {
    return AEO_ABI_VERSION;
}

static int32_t fail(AeoOutcome *out, int32_t code, int32_t locus) {
    out->code = code;
    out->locus = locus;
    return code;
}

int32_t aeo_run_hourly_dispatch(const double cfg[AEO_CFG_N],
                                const double *solar, const double *wind,
                                const double *lmp, const double *temp,
                                const uint32_t n[AEO_SERIES_N], AeoOutcome *out) {
    if (!out) {
        return AEO_ERR_ABI;
    }
    out->code = AEO_OK;
    out->locus = 0;
    out->trace_fnv1a64 = 0;
    out->digest_fnv1a64 = 0;
    for (uint32_t i = 0; i < AEO_RES_N; i++) {
        out->result[i] = 0.0;
    }
    if (!cfg || !solar || !wind || !lmp || !temp || !n) {
        return fail(out, AEO_ERR_ABI, 0);
    }

    for (uint32_t i = 0; i < AEO_CFG_N; i++) {
        const double v = cfg[i];
        const CfgRule *r = &CFG_RULES[i];
        if (!is_finite(v)) {
            return fail(out, AEO_ERR_NON_FINITE, (int32_t)i);
        }
        if (v < r->lo || v > r->hi || (r->lo_open && v <= r->lo)) {
            return fail(out, AEO_ERR_BOUND, (int32_t)i);
        }
        if (r->integer && __builtin_floor(v) != v) {
            return fail(out, AEO_ERR_SHAPE, (int32_t)i);
        }
    }
    for (uint32_t s = 0; s < AEO_SERIES_N; s++) {
        if (n[s] != AEO_HOURS) {
            return fail(out, AEO_ERR_SHAPE, AEO_LOCUS_SHAPE + (int32_t)s);
        }
    }
    const double *series[AEO_SERIES_N] = {solar, wind, lmp, temp};
    for (uint32_t h = 0; h < AEO_HOURS; h++) {
        for (uint32_t s = 0; s < AEO_SERIES_N; s++) {
            const double v = series[s][h];
            if (!is_finite(v)) {
                return fail(out, AEO_ERR_NON_FINITE, (int32_t)((s + 1) * 100000 + h));
            }
            if (v < SERIES_LO[s] || v > SERIES_HI[s]) {
                return fail(out, AEO_ERR_BOUND, (int32_t)((s + 1) * 100000 + h));
            }
        }
    }

    const double it = cfg[0], pue_base = cfg[1], pue_slope = cfg[2], solar_cap = cfg[3],
                 wind_cap = cfg[4], e0 = cfg[5], p_bess = cfg[6], rte = cfg[7], fade = cfg[8],
                 gas_cap = cfg[9], heat_rate = cfg[10], gas_price = cfg[11],
                 gas_vom = cfg[12], grid_cap = cfg[13], forced = cfg[14], lmp_mult = cfg[15],
                 capex_m = cfg[16], opex_m = cfg[17], rate = cfg[18], years = cfg[19],
                 delay_m = cfg[20], voll = cfg[21], dk_start = cfg[22], dk_hours = cfg[23],
                 dk_adder = cfg[24], ht_start = cfg[25], ht_hours = cfg[26], ht_delta = cfg[27];

    const double eta = __builtin_sqrt(rte);
    const double mc_gas = heat_rate * gas_price + gas_vom;
    const int bess_on = e0 > 0.0 && p_bess > 0.0;
    double soc = 0.5 * e0;
    double dis_internal = 0.0;
    double efc = 0.0;
    double cap_frac = 1.0;
    const double dk_end = dk_start + dk_hours;
    const double ht_end = ht_start + ht_hours;

    double total_load = 0.0, pue_sum = 0.0, peak = 0.0, ren_gen = 0.0, ren_direct = 0.0,
           curtailed = 0.0, chg_sum = 0.0, dis_sum = 0.0, gas_sum = 0.0, gas_fuel = 0.0,
           grid_sum = 0.0, grid_cost = 0.0, gas_cost = 0.0, lole = 0.0, eens = 0.0,
           cfe = 0.0, max_resid = 0.0;
    uint64_t trace = FNV_OFFSET_64;

    for (uint32_t h = 0; h < AEO_HOURS; h++) {
        const double hd = (double)h;
        const int dunkel = dk_start >= 0.0 && hd >= dk_start && hd < dk_end;
        const int heat = ht_start >= 0.0 && hd >= ht_start && hd < ht_end;

        double t = temp[h];
        if (heat) {
            t = t + ht_delta;
        }
        double excess = t - 20.0;
        if (excess < 0.0) {
            excess = 0.0;
        }
        const double pue = pue_base + pue_slope * excess;
        const double load = it * pue;

        double s = solar[h];
        double w = wind[h];
        if (dunkel) {
            s = 0.0;
            w = 0.0;
        }
        double price = lmp[h] * lmp_mult;
        if (dunkel) {
            price = price + dk_adder;
        }

        const double gen_s = solar_cap * s;
        const double gen_w = wind_cap * w;
        const double raw = gen_s + gen_w;
        const double forced_mwh = raw * forced;
        const double avail = raw - forced_mwh;
        const double direct = load < avail ? load : avail;
        const double surplus = avail - direct;
        double deficit = load - direct;

        double chg = 0.0;
        if (bess_on) {
            const double e_cap = e0 * cap_frac;
            if (soc > e_cap) {
                soc = e_cap;
            }
            if (surplus > 0.0) {
                const double headroom = e_cap - soc;
                const double lim = headroom / eta;
                chg = surplus;
                if (p_bess < chg) {
                    chg = p_bess;
                }
                if (lim < chg) {
                    chg = lim;
                }
                const double stored = chg * eta;
                soc = soc + stored;
            }
        }
        const double spill = surplus - chg;
        const double curt = forced_mwh + spill;

        double bout = 0.0;
        if (bess_on && deficit > 0.0) {
            const double avail_out = soc * eta;
            bout = deficit;
            if (p_bess < bout) {
                bout = p_bess;
            }
            if (avail_out < bout) {
                bout = avail_out;
            }
            const double drawn = bout / eta;
            soc = soc - drawn;
            if (soc < 0.0) {
                soc = 0.0;
            }
            dis_internal = dis_internal + drawn;
            deficit = deficit - bout;
            efc = dis_internal / e0;
            const double wear = fade * efc;
            cap_frac = 1.0 - wear;
            if (cap_frac < 0.6) {
                cap_frac = 0.6;
            }
        }

        double grid = 0.0;
        double gas = 0.0;
        if (price <= mc_gas) {
            grid = deficit < grid_cap ? deficit : grid_cap;
            deficit = deficit - grid;
            gas = deficit < gas_cap ? deficit : gas_cap;
            deficit = deficit - gas;
        } else {
            gas = deficit < gas_cap ? deficit : gas_cap;
            deficit = deficit - gas;
            grid = deficit < grid_cap ? deficit : grid_cap;
            deficit = deficit - grid;
        }
        double unserved = deficit;
        if (unserved < 0.0) {
            unserved = 0.0;
        }
        if (unserved > 1e-9) {
            lole = lole + 1.0;
            eens = eens + unserved;
        }

        total_load = total_load + load;
        pue_sum = pue_sum + pue;
        if (load > peak) {
            peak = load;
        }
        ren_gen = ren_gen + raw;
        ren_direct = ren_direct + direct;
        curtailed = curtailed + curt;
        chg_sum = chg_sum + chg;
        dis_sum = dis_sum + bout;
        gas_sum = gas_sum + gas;
        const double fuel = gas * heat_rate;
        gas_fuel = gas_fuel + fuel;
        grid_sum = grid_sum + grid;
        const double cost_g = grid * price;
        grid_cost = grid_cost + cost_g;
        const double cost_f = gas * mc_gas;
        gas_cost = gas_cost + cost_f;
        const double matched = direct + bout;
        cfe = cfe + matched;

        double supplied = matched + grid;
        supplied = supplied + gas;
        supplied = supplied + unserved;
        double resid = load - supplied;
        if (resid < 0.0) {
            resid = -resid;
        }
        if (resid > max_resid) {
            max_resid = resid;
        }

        trace = fnv_double(trace, quantize(soc));
        trace = fnv_double(trace, quantize(grid));
        trace = fnv_double(trace, quantize(gas));
        trace = fnv_double(trace, quantize(curt));
        trace = fnv_double(trace, quantize(unserved));
    }

    double growth = 1.0;
    for (int i = 0; i < (int)years; i++) {
        growth = growth * (1.0 + rate);
    }
    double crf;
    if (rate == 0.0) {
        crf = 1.0 / years;
    } else {
        const double num = rate * growth;
        const double den = growth - 1.0;
        crf = num / den;
    }
    const double capex_usd = capex_m * 1e6;
    const double ann_capex = capex_usd * crf;
    const double opex_usd = opex_m * 1e6;
    const double monthly = rate / 12.0;
    double carry = 1.0;
    for (int i = 0; i < (int)delay_m; i++) {
        carry = carry * (1.0 + monthly);
    }
    double served = total_load - eens;
    if (served < 1e-9) {
        served = 1e-9;
    }
    double cost = ann_capex + opex_usd;
    cost = cost + grid_cost;
    cost = cost + gas_cost;
    const double lcoe = cost / served;
    const double delayed = ann_capex * carry;
    const double penalty = eens * voll;
    double adj = delayed + opex_usd;
    adj = adj + grid_cost;
    adj = adj + gas_cost;
    adj = adj + penalty;
    const double adj_cost = adj / served;

    double *r = out->result;
    r[0] = total_load;
    r[1] = pue_sum / (double)AEO_HOURS;
    r[2] = peak;
    r[3] = ren_gen;
    r[4] = ren_direct;
    r[5] = curtailed;
    r[6] = ren_gen > 0.0 ? curtailed / ren_gen : 0.0;
    r[7] = chg_sum;
    r[8] = dis_sum;
    r[9] = efc;
    r[10] = cap_frac;
    r[11] = gas_sum;
    r[12] = gas_fuel;
    r[13] = grid_sum;
    r[14] = lole;
    r[15] = eens;
    r[16] = cfe / total_load;
    r[17] = grid_cost;
    r[18] = gas_cost;
    r[19] = ann_capex;
    r[20] = lcoe;
    r[21] = adj_cost;
    r[22] = max_resid;

    uint64_t digest = FNV_OFFSET_64;
    for (uint32_t i = 0; i < AEO_RES_N; i++) {
        digest = fnv_double(digest, r[i]);
    }
    out->trace_fnv1a64 = trace;
    out->digest_fnv1a64 = digest;
    return AEO_OK;
}
