//
// Created by cfif on 29.05.2026.
//
#include "dig_pot.h"

// Потенциометр 100 кОм
static const uint32_t pot_100k[256] = {
        // 0-9
        142, 518, 897, 1275, 1653, 2031, 2409, 2787, 3165, 3543,
        // 10-19
        3918, 4296, 4674, 5052, 5430, 5808, 6186, 6564, 6942, 7320,
        // 20-29
        7640, 8020, 8400, 8775, 9150, 9525, 9900, 10275, 10650, 11025,
        // 30-39
        11400, 11775, 12150, 12525, 12900, 13275, 13650, 14025, 14400, 14775,
        // 40-49
        15150, 15527, 15904, 16281, 16658, 17035, 17412, 17789, 18166, 18543,
        // 50-59
        18920, 19294, 19668, 20042, 20416, 20790, 21164, 21538, 21912, 22286,
        // 60-69
        22660, 23034, 23408, 23782, 24156, 24530, 24904, 25278, 25652, 26026,
        // 70-79
        26400, 26772, 27144, 27516, 27888, 28260, 28632, 29004, 29376, 29748,
        // 80-89
        30120, 30496, 30872, 31248, 31624, 32000, 32376, 32752, 33128, 33504,
        // 90-99
        33880, 34247, 34614, 34981, 35348, 35715, 36082, 36449, 36816, 37183,
        // 100-109
        37550, 37925, 38300, 38675, 39050, 39425, 39800, 40175, 40550, 40925,
        // 110-119
        41300, 41668, 42036, 42404, 42772, 43140, 43508, 43876, 44244, 44612,
        // 120-129
        44980, 45338, 45696, 46054, 46412, 46770, 47128, 47486, 47844, 48202,
        // 130-139
        48560, 48931, 49302, 49673, 50044, 50415, 50786, 51157, 51528, 51899,
        // 140-149
        52270, 52643, 53016, 53389, 53762, 54135, 54508, 54881, 55254, 55627,
        // 150-159
        56000, 56352, 56704, 57056, 57408, 57760, 58112, 58464, 58816, 59168,
        // 160-169
        59520, 59868, 60216, 60564, 60912, 61260, 61608, 61956, 62304, 62652,
        // 170-179
        63000, 63300, 63600, 63900, 64200, 64500, 64800, 65100, 65400, 65700,
        // 180-189
        66000, 66400, 66800, 67200, 67600, 68000, 68400, 68800, 69200, 69600,
        // 190-199
        70000, 70330, 70660, 70990, 71320, 71650, 71980, 72310, 72640, 72970,
        // 200-209
        73300, 73730, 74160, 74590, 75020, 75450, 75880, 76310, 76740, 77170,
        // 210-219
        77600, 77900, 78200, 78500, 78800, 79100, 79400, 79700, 80000, 80300,
        // 220-229
        80600, 80940, 81280, 81620, 81960, 82300, 82640, 82980, 83320, 83660,
        // 230-239
        84000, 84300, 84600, 84900, 85200, 85500, 85800, 86100, 86400, 86700,
        // 240-249
        87000, 87350, 87700, 88050, 88400, 88750, 89100, 89450, 89800, 90150,
        // 250-255
        90500, 90900, 91300, 91700, 92100, 93400
};

// Потенциометр 10 кОм
static const uint32_t pot_10k[256] = {
        // 0-9
        142, 183, 222, 264, 305, 346, 387, 428, 469, 510,
        // 10-19
        548, 589, 629, 670, 711, 752, 793, 834, 875, 916,
        // 20-29
        940, 981, 1022, 1063, 1104, 1145, 1186, 1227, 1268, 1309,
        // 30-39
        1347, 1386, 1425, 1464, 1503, 1542, 1581, 1620, 1659, 1698,
        // 40-49
        1736, 1775, 1814, 1853, 1892, 1931, 1970, 2009, 2048, 2087,
        // 50-59
        2126, 2167, 2208, 2249, 2290, 2331, 2372, 2413, 2454, 2495,
        // 60-69
        2533, 2572, 2611, 2650, 2689, 2728, 2767, 2806, 2845, 2884,
        // 70-79
        2924, 2963, 3002, 3041, 3080, 3119, 3158, 3197, 3236, 3275,
        // 80-89
        3313, 3354, 3395, 3436, 3477, 3518, 3559, 3600, 3641, 3682,
        // 90-99
        3720, 3759, 3798, 3837, 3876, 3915, 3954, 3993, 4032, 4071,
        // 100-109
        4112, 4153, 4194, 4235, 4276, 4317, 4358, 4399, 4440, 4481,
        // 110-119
        4518, 4557, 4596, 4635, 4674, 4713, 4752, 4791, 4830, 4869,
        // 120-129
        4906, 4945, 4984, 5023, 5062, 5101, 5140, 5179, 5218, 5257,
        // 130-139
        5296, 5337, 5378, 5419, 5460, 5501, 5542, 5583, 5624, 5665,
        // 140-149
        5704, 5744, 5784, 5824, 5864, 5904, 5944, 5984, 6024, 6064,
        // 150-159
        6097, 6134, 6171, 6208, 6245, 6282, 6319, 6356, 6393, 6430,
        // 160-169
        6460, 6500, 6540, 6580, 6620, 6660, 6700, 6740, 6780, 6820,
        // 170-179
        6860, 6900, 6940, 6980, 7020, 7060, 7100, 7140, 7180, 7220,
        // 180-189
        7260, 7300, 7340, 7380, 7420, 7460, 7500, 7540, 7580, 7620,
        // 190-199
        7660, 7699, 7738, 7777, 7816, 7855, 7894, 7933, 7972, 8011,
        // 200-209
        8050, 8089, 8128, 8167, 8206, 8245, 8284, 8323, 8362, 8401,
        // 210-219
        8440, 8480, 8520, 8560, 8600, 8640, 8680, 8720, 8760, 8800,
        // 220-229
        8840, 8878, 8916, 8954, 8992, 9030, 9068, 9106, 9144, 9182,
        // 230-239
        9220, 9260, 9300, 9340, 9380, 9420, 9460, 9500, 9540, 9580,
        // 240-249
        9620, 9660, 9700, 9740, 9780, 9820, 9860, 9900, 9940, 9980,
        // 250-255
        10020, 10040, 10060, 10080, 10180, 10200
};

#define R_CORRECTION 150//230  // вычитаемая поправка (Ом)

uint32_t find_steps_for_resistance(uint32_t target_ohm, uint8_t *step_100k, uint8_t *step_10k) {
    uint32_t best_r = 0;
    uint32_t best_diff = 0xFFFFFFFF;
    uint8_t best_n100 = 0, best_n10 = 0;

    for (uint16_t n100 = 0; n100 < 256; n100++) {
        uint32_t r100 = pot_100k[n100];

        for (uint16_t n10 = 0; n10 < 256; n10++) {
            uint32_t r10 = pot_10k[n10];
            uint32_t r_total = r100 + r10;

            r_total -= R_CORRECTION;

            uint32_t diff = (r_total > target_ohm) ? (r_total - target_ohm) : (target_ohm - r_total);

            if (diff < best_diff) {
                best_diff = diff;
                best_r = r_total;
                best_n100 = n100;
                best_n10 = n10;

                if (diff == 0) {
                    *step_100k = best_n100;
                    *step_10k = best_n10;
                    return best_r;
                }
            }
        }
    }

    *step_100k = best_n100;
    *step_10k = best_n10;
    return best_r;
}

#define R_CORRECTION_AUTO 300//230  // вычитаемая поправка (Ом)

uint32_t find_steps_for_resistance_auto(uint32_t target_ohm,
                                        uint8_t *step_100k_1,
                                        uint8_t *step_100k_2,
                                        uint8_t *step_100k_3,
                                        uint8_t *step_10k) {

    uint32_t remaining;
    uint32_t best_r = 0;
    uint32_t best_diff = 0xFFFFFFFF;
    uint8_t best_n100_1 = 0, best_n100_2 = 0, best_n100_3 = 0, best_n10 = 0;

    // Пробуем разные варианты количества дополнительных 100к (0, 1 или 2)
    for (uint8_t extra_pots = 0; extra_pots <= 2; extra_pots++) {

        // Вычитаем сопротивление дополнительных потенциометров (каждый на 255 = максимум)
        uint32_t extra_resistance = extra_pots * pot_100k[255];

        if (target_ohm <= extra_resistance) {
            // Если цель меньше или равна сопротивлению дополнительных - не используем этот вариант
            continue;
        }

        remaining = target_ohm - extra_resistance;

        // Ищем оптимальную комбинацию для оставшегося сопротивления
        for (uint16_t n100_1 = 0; n100_1 < 256; n100_1++) {
            uint32_t r100_1 = pot_100k[n100_1];

            for (uint16_t n10 = 0; n10 < 256; n10++) {
                uint32_t r10 = pot_10k[n10];
                uint32_t r_total = r100_1 + r10 - R_CORRECTION_AUTO;

                uint32_t diff = (r_total > remaining) ? (r_total - remaining) : (remaining - r_total);

                if (diff < best_diff) {
                    best_diff = diff;
                    best_r = r_total + extra_resistance;
                    best_n100_1 = n100_1;
                    best_n10 = n10;

                    // Устанавливаем дополнительные потенциометры
                    if (extra_pots >= 1) {
                        best_n100_2 = 255;
                    } else {
                        best_n100_2 = 0;
                    }

                    if (extra_pots >= 2) {
                        best_n100_3 = 255;
                    } else {
                        best_n100_3 = 0;
                    }

                    if (diff == 0) {
                        *step_100k_1 = best_n100_1;
                        *step_100k_2 = best_n100_2;
                        *step_100k_3 = best_n100_3;
                        *step_10k = best_n10;
                        return best_r;
                    }
                }
            }
        }
    }

    *step_100k_1 = best_n100_1;
    *step_100k_2 = best_n100_2;
    *step_100k_3 = best_n100_3;
    *step_10k = best_n10;
    return best_r;
}


// Функция получения сопротивления по температуре с линейной интерполяцией
uint32_t get_resistance_by_temperature_linear(const TablePoint *table, int table_size, int16_t temperature) {
    // Проверка границ
    if (temperature <= table[table_size - 1].temp) {
        return (uint32_t)table[table_size - 1].resistance;
    }
    if (temperature >= table[0].temp) {
        return (uint32_t)table[0].resistance;
    }

    // Поиск интервала по температуре (таблица отсортирована по убыванию температуры)
    int left = 0;
    int right = table_size - 1;

    for (int i = 0; i < table_size - 1; i++) {
        if (temperature <= table[i].temp && temperature >= table[i + 1].temp) {
            left = i;
            right = i + 1;
            break;
        }
    }

    // Линейная интерполяция сопротивления
    float t = ((float)temperature - (float)table[left].temp) /
              ((float)table[right].temp - (float)table[left].temp);

    return (uint32_t)(table[left].resistance + t * (table[right].resistance - table[left].resistance));
}