#include "calculate_price.h"
#include "configuration.h"
#include "calculator_functions.h"
#include "payment_option.h"
#include "utilities.h"
#include "tariff_global_defines.h"
#include "period_year.h"

#include <QFile>
#include <QFileInfo>
#include <QDateTime>
#include <QDebug>
#include <QList>

QString const CalcState::SUCCESS = "SUCCESS";
QString const CalcState::ERROR_PARSING_ZONE_NR = "ERROR_PARSING_ZONE_NR";
QString const CalcState::ERROR_LOADING_TARIFF = "ERROR_LOADING_TARIFF";
QString const CalcState::ERROR_PARSING_TARIFF = "ERROR_PARSING_TARIFF";
QString const CalcState::NEGATIVE_PARKING_TIME = "NEGATIVE_PARKING_TIME";
QString const CalcState::INVALID_START_DATE = "INVALID_START_DATE";
QString const CalcState::WRONG_PARAM_VALUES = "WRONG_PARAM_VALUES";
QString const CalcState::WRONG_ISO_TIME_FORMAT = "WRONG_ISO_TIME_FORMAT";
QString const CalcState::ABOVE_MAX_PARKING_TIME = "ABOVE_MAX_PARKING_TIME";
QString const CalcState::BELOW_MIN_PARKING_TIME = "BELOW_MIN_PARKING_TIME";
QString const CalcState::BELOW_MIN_PARKING_PRICE = "BELOW_MIN_PARKING_PRICE";
QString const CalcState::ABOVE_MAX_PARKING_PRICE = "ABOVE_MAX_PARKING_PRICE";
QString const CalcState::OVERPAID = "OVERPAID";
QString const CalcState::OUTSIDE_ALLOWED_PARKING_TIME = "OUTSIDE_ALLOWED_PARKING_TIME";
QString const CalcState::SUCCESS_MAXPRICE = "SUCCESS_MAXPRICE";

QList<int> CALCULATE_LIBRARY_API get_time_steps(Configuration *cfg) {
    return Calculator::GetInstance().GetTimeSteps(cfg);
}

int CALCULATE_LIBRARY_API get_minimal_parkingtime(Configuration const *cfg,
                                                  PERMIT_TYPE permitType,
                                                  int paymentOptionIndex) {
    int minTime = 0;

    paymentOptionIndex = getPaymentOptionIndex(*cfg);
    if (paymentOptionIndex == -1) {
        paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
    }

    qCritical() << __func__ << __LINE__ << "paymentOptionIndex" << paymentOptionIndex;
    qCritical() << __func__ << __LINE__ << "permit" << PermitType(permitType).toString();

    switch(permitType) {
    case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
        qCritical() << __LINE__ << Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
        minTime = cfg->getPaymentOptions(paymentOptionIndex).pop_min_time;
        qCritical() << __func__ << __LINE__ << minTime;
    } break;
    case PERMIT_TYPE::DAY_TICKET_ADULT: {
    } break;
    case PERMIT_TYPE::DAY_TICKET_TEEN: {
    } break;
    case PERMIT_TYPE::DAY_TICKET_CHILD: {
    } break;
    default:
        // for each new sell-procedure, recomute the timesteps. implicitly, set
        // the minimal parking time.
        Calculator::GetInstance().ResetTimeSteps(paymentOptionIndex);
        qCritical() << __LINE__ << Calculator::GetInstance().GetTimeSteps((Configuration *)cfg, paymentOptionIndex);
        minTime = qRound(cfg->getPaymentOptions(paymentOptionIndex).pop_min_time);
    }

    qCritical() << "minTime" << minTime;
    return minTime;
}

int CALCULATE_LIBRARY_API get_maximal_parkingtime(Configuration const *cfg,
                                                  PERMIT_TYPE permitType,
                                                  int paymentOptionIndex) {

    paymentOptionIndex = getPaymentOptionIndex(*cfg);
    if (paymentOptionIndex == -1) {
        paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
    }

    int maxTime = 0;

    switch(permitType) {
    case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
        maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time;
    } break;
    case PERMIT_TYPE::DAY_TICKET_ADULT: {
    } break;
    case PERMIT_TYPE::DAY_TICKET_TEEN: {
    } break;
    case PERMIT_TYPE::DAY_TICKET_CHILD: {
    } break;
    default: ;
        maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time;
    }

    return maxTime;
}

int CALCULATE_LIBRARY_API get_minimal_parkingprice(Configuration *cfg,
                                                   PERMIT_TYPE permitType,
                                                   int paymentOptionIndex,
                                                   QDateTime const &start) {
    int minPrice = -1;

    if ((paymentOptionIndex = getPaymentOptionIndex(*cfg, start)) == -1) {
        paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
    }

    int payment_method_id = cfg->getPaymentOptions(paymentOptionIndex).pop_payment_method_id;

    if (payment_method_id == PaymentMethod::Degressive) {
        // Degressive: new for Fuchs Technik (500), ValserAlm (Fane):
        // the minimal price has to be calculated, in cannot be hard coded into
        // the tariff file.
        // The working times have a reference into the payment rates. Two special
        // entries (with the numbers 1000/1001) point to the respective prices.
        switch(permitType) {
            default: {
                // find the correct work time range
                int weekDay = start.date().dayOfWeek();
                std::optional<QVector<ATBWeekDaysWorktime>> const &wd = cfg->getAllWeekDayWorkTimes();
                if (wd.has_value()) {
                    QVector<ATBWeekDaysWorktime> const &vec = wd.value();
                    for (int i = 0; i < vec.size(); ++i) {
                        ATBWeekDaysWorktime const &wt = vec[i];
                        if (wt.pwd_period_day_in_week_id == weekDay) {
                            if (start.time() >= QTime::fromString(QString::fromStdString(wt.pwd_time_from), Qt::ISODate)
                             && start.time() <= QTime::fromString(QString::fromStdString(wt.pwd_time_to), Qt::ISODate)) {
                                // found worktime range
                                int pop_id = wt.pwd_pop_id; // 1000 or 1001
                                for (auto[itr, rangeEnd] = cfg->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
                                    i = vec.size(); // to leave outer loop
                                    minPrice = itr->second.pra_price; // this is now the minimal price
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    } else {
        switch(permitType) {
        case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
            minPrice = cfg->getPaymentOptions(paymentOptionIndex).pop_min_price;
        } break;
        case PERMIT_TYPE::DAY_TICKET_ADULT: {
        } break;
        case PERMIT_TYPE::DAY_TICKET_TEEN: {
        } break;
        case PERMIT_TYPE::DAY_TICKET_CHILD: {
        } break;
        case PERMIT_TYPE::DAY_TICKET: {
            minPrice = compute_product_price(cfg, permitType, start);
        } break;
        default:
            minPrice = cfg->getPaymentOptions(paymentOptionIndex).pop_min_price;
        }
    }

    return minPrice;
}

int CALCULATE_LIBRARY_API compute_product_price(Configuration const *cfg,
                                                PERMIT_TYPE permitType,
                                                QDateTime const &start,
                                                QDateTime *productStart,
                                                QDateTime *productEnd) {

    switch(permitType) {
    case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
    } break;
    case PERMIT_TYPE::DAY_TICKET_CHILD:
        // [[fallthrough]];
    case PERMIT_TYPE::DAY_TICKET_TEEN:
        // [[fallthrough]];
    case PERMIT_TYPE::FOOD_STAMP:
        // [[fallthrough]];
    case PERMIT_TYPE::DAY_TICKET_ADULT: {
        std::optional<QVector<ATBTariffProduct>> products = cfg->getTariffProductForProductId(permitType);
        if (products) {
            QVector<ATBTariffProduct> product = products.value();
            if (product.size() > 0) {
                ATBTariffProduct const &p = product[0];
                return p.m_tariff_product_price;
#if 0
                // in case we do not have prepaid-option
                QTime const &currentTime = QDateTime::currentDateTime().time();

                if (p.m_tariff_product_start <= currentTime && currentTime <= p.m_tariff_product_end) {
                    return p.m_tariff_product_price;
                } else {
                    qCritical() << "(" << __func__ << ":" << __LINE__ << ")"
                                << "ERROR currentTime"
                                << currentTime.toString(Qt::ISODate)
                                << "INVALID ("
                                << p.m_tariff_product_start.toString(Qt::ISODate)
                                << p.m_tariff_product_end.toString(Qt::ISODate) << ")";
                }
#endif
            }
        }
    } break;
    case PERMIT_TYPE::INVALID:
        // [[fallthrough]];
    case PERMIT_TYPE::DAY_TICKET: {
        std::optional<QVector<ATBTariffProduct>> products = cfg->getTariffProductForProductId(permitType);
        if (products) {
            QVector<ATBTariffProduct> product = products.value();
            int product_price = 0;

            if (productStart && productEnd) {
                *productStart = start;
                *productEnd = start;
                if (product.size() > 0) {
                    productStart->setTime(product[0].getTimeStart());
                    productEnd->setTime(product[0].getTimeEnd());
                }
            }

            for (QVector<ATBTariffProduct>::size_type i=0; i<product.size(); ++i) {
                ATBTariffProduct const &p = product[i];
                QTime const &startTime = p.getTimeStart();
                QTime const &endTime = p.getTimeEnd();

                // qCritical() << __LINE__ << startTime.toString(Qt::ISODate);
                // qCritical() << __LINE__ << endTime.toString(Qt::ISODate);
                // qCritical() << __LINE__ << start.toString(Qt::ISODate);

                if (start.time() >= startTime && start.time() < endTime) {
                    product_price = p.getProductPrice();
                    if (productStart && productEnd) {
                        productStart->setTime(startTime);
                        productEnd->setTime(endTime);
                    }
                }
            }

            return product_price;
        } else {
            // SZEGED
            int const pop_daily_card_price = cfg->getPaymentOptions().pop_daily_card_price;

            qDebug() << QString("(%1:%2) no products defined in tariff-file").arg(__func__).arg(__LINE__);
            qDebug() << QString("(%1:%2) pop_daily_card_price=%3").arg(__func__).arg(__LINE__).arg(pop_daily_card_price);

            // static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);
            // return Utilities::getDailyTicketCardPrice(cfg, paymentMethodId);

            return pop_daily_card_price;
        }
    } break;
    case PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET: {
        std::optional<QVector<ATBTariffProduct>> products = cfg->getTariffProductForProductId(permitType);
        if (products) {
            int product_price = 0;
            QVector<ATBTariffProduct> product = products.value();

            if (product.size() > 0) {
                if (productStart && productEnd) {
                    int pop_min_time = get_minimal_parkingtime(cfg, PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET); // in minutes
                    int pop_max_time = get_maximal_parkingtime(cfg, PERMIT_TYPE::TWENTY_FOUR_HOURS_TICKET); // in minutes
                    if (pop_max_time >= pop_min_time) {
                        *productStart = start;
                        *productEnd = start.addSecs(pop_max_time*60);
                        product_price = product[0].getProductPrice();
                    }
                }
            }

            return product_price;
        }

    } break;
    case PERMIT_TYPE::SHORT_TERM_PARKING_PKW: {
        PermitType p(permitType);
        std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
        if (paymentOption.has_value()) {
            ATBPaymentOption option = paymentOption.value();
            int const pop_daily_card_price = option.pop_daily_card_price;
            qCritical() << "SHORT_TERM_PARKING_PKW: daily ticket price" << pop_daily_card_price;
            return pop_daily_card_price;
        }
    } break;
    case PERMIT_TYPE::SHORT_TERM_PARKING_BUS: {
        qCritical() << "TODO: SHORT_TERM_PARKING_BUS";
    } break;
    case PERMIT_TYPE::SHORT_TERM_PARKING_CAMPER: {
        qCritical() << "TODO: SHORT_TERM_PARKING_CAMPER";
    } break;
    case PERMIT_TYPE::DAY_TICKET_PKW: {
        PermitType p(permitType);
        std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
        if (paymentOption.has_value()) {
            ATBPaymentOption option = paymentOption.value();
            int const pop_daily_card_price = option.pop_daily_card_price;
            qCritical() << "DAY_TICKET_PKW: daily ticket price" << pop_daily_card_price;
            return pop_daily_card_price;
        }
    } break;
    case PERMIT_TYPE::DAY_TICKET_BUS: {
        PermitType p(permitType);
        std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
        if (paymentOption.has_value()) {
            ATBPaymentOption option = paymentOption.value();
            int const pop_daily_card_price = option.pop_daily_card_price;
            qCritical() << "DAY_TICKET_BUS: daily ticket price" << pop_daily_card_price;
            return pop_daily_card_price;
        }
    } break;
    case PERMIT_TYPE::DAY_TICKET_CAMPER: {
        PermitType p(permitType);
        std::optional<ATBPaymentOption> const paymentOption = cfg->getPaymentOptionForKey(p.get());
        if (paymentOption.has_value()) {
            ATBPaymentOption option = paymentOption.value();
            int const pop_daily_card_price = option.pop_daily_card_price;
            qCritical() << "DAY_TICKET_CAMPER: daily ticket price" << pop_daily_card_price;
            return pop_daily_card_price;
        }
    } break;
    default:
      break;
    }

    return 0;
}

int CALCULATE_LIBRARY_API get_maximal_parkingprice(Configuration *cfg,
                                                   PERMIT_TYPE permitType,
                                                   int paymentOptionIndex) {
    int maxPrice = -1;
    static const PaymentMethod paymentMethodId = Utilities::getPaymentMethodId(cfg);

    if ((paymentOptionIndex = getPaymentOptionIndex(*cfg)) == -1) {
        paymentOptionIndex = cfg->getPaymentOptionIndex(permitType);
    }

    switch(permitType) {
    case PERMIT_TYPE::SHORT_TERM_PARKING: { // e.g. szeged (customer_281)
        if (paymentMethodId == PaymentMethod::Progressive
         || paymentMethodId == PaymentMethod::Steps
         || paymentMethodId == PaymentMethod::Unified) {
            //maxPrice = Utilities::getMaximalParkingPrice(cfg, paymentMethodId);
            ATBPaymentOption const &po = cfg->getPaymentOptions(paymentOptionIndex);
            maxPrice = po.pop_max_price; // maxTime is given in minutes
        } else { // PaymentMethod::Linear -> e.g. szeged
            int const key = cfg->getPaymentOptions(paymentOptionIndex).pop_id;
            int const maxTime = cfg->getPaymentOptions(paymentOptionIndex).pop_max_time; // maxTime is given in minutes
            std::optional<QVector<ATBPaymentRate>> const &pv = cfg->getPaymentRateForKey(key);
            if (pv) {
                QVector<ATBPaymentRate> const &paymentRate = pv.value();
                if (paymentRate.size() > 0) {
                    int const price = paymentRate.last().pra_price; // price is given per hour
                    maxPrice = qRound((maxTime * price) / 60.0f);
                }
            }
        }
    } break;
    case PERMIT_TYPE::DAY_TICKET_ADULT:
        break;
    case PERMIT_TYPE::DAY_TICKET_TEEN:
        break;
    case PERMIT_TYPE::DAY_TICKET_CHILD:
        break;
    case PERMIT_TYPE::DAY_TICKET_BUS:
        break;
    case PERMIT_TYPE::DAY_TICKET_CAMPER:
        break;
    case PERMIT_TYPE::DAY_TICKET_PKW:
        break;
    case PERMIT_TYPE::SHORT_TERM_PARKING_BUS: {
        std::optional<ATBPaymentOption> po = cfg->getPaymentOptionForKey(permitType);
        if (po.has_value()) {
            ATBPaymentOption option = po.value();
            return option.pop_max_price;
        }
    } break;
    case PERMIT_TYPE::SHORT_TERM_PARKING_PKW: {
        std::optional<ATBPaymentOption> po = cfg->getPaymentOptionForKey(permitType);
        if (po.has_value()) {
            ATBPaymentOption option = po.value();
            return option.pop_max_price;
        }
    } break;
    case PERMIT_TYPE::SHORT_TERM_PARKING_CAMPER:
        break;
    default: ;
    }

    return maxPrice;
}

int CALCULATE_LIBRARY_API get_zone_nr(int zone)
{
    if(zone > -1) return zone;
    else
    {
        QFile zone("/etc/zone_nr");
        if (zone.exists()) {
            QFileInfo finfo(zone);
            if (finfo.size() <= 4) { // decimal 000\n
                if (zone.open(QIODevice::ReadOnly | QIODevice::Text)) {
                    QTextStream in(&zone);
                    return in.readLine(100).toInt();
                }
            }
        }
        return -1;
    }
}

CalcState CALCULATE_LIBRARY_API init_tariff(parking_tariff_t **tariff, char const *config_file) {
    *tariff = new Configuration();

    CalcState calcState;
#if __linux__

    int const zone = get_zone_nr();

    // DEBUG
    qCritical() << "init_tariff:";
    qCritical() << "      ... zone = " << zone;

    if (zone <= 0) {
        delete *tariff;
        *tariff = nullptr;
        return calcState.set(CalcState::State::ERROR_PARSING_ZONE_NR);
    }

    QString confFile(config_file);
    if (!confFile.endsWith(QChar('/'))) {
        confFile += "/";
    }

    char buffer[32];
    memset(buffer, 0x00, sizeof(buffer));
    snprintf(buffer, sizeof(buffer)-1, "tariff%02d.json", zone);
    confFile += buffer;
#else // windows
    QString confFile(config_file);
#endif

    // DEBUG
    qCritical() << "      ... confFile = " << confFile;

    QFile fname(confFile);
    if (fname.exists() &&
            fname.open(QIODevice::ReadOnly | QIODevice::Text)) {
        // DEBUG
        qCritical() << "      ... confFile is open";

        QString json = fname.readAll();
        if (! (*tariff)->ParseJson(*tariff, json.toStdString().c_str())) {
            delete *tariff;
            *tariff = nullptr;
            qCritical() << "      ... error parsing tariff";
            return calcState.set(CalcState::State::ERROR_PARSING_TARIFF);
        }
    } else {
        delete *tariff;
        *tariff = nullptr;
            qCritical() << "      ... error loading tariff";
        return calcState.set(CalcState::State::ERROR_LOADING_TARIFF);
    }

    qCritical() << "init_tariff: Parsing tariff config (" << confFile << ")";

    return calcState;
}

void CALCULATE_LIBRARY_API free_tariff(parking_tariff_t *tariff) {
    if (tariff != nullptr) {
        delete tariff;
    }
}

//
// UpDown 1 -> up; 0 -> down
int CALCULATE_LIBRARY_API compute_next_timestep(parking_tariff_t *tariff, int currentTimeMinutes,
                                                int UpDown, PermitType const &permitType)
{

    qCritical() << __LINE__ << "compute_next_timestep()     currentTimeMinutes: " << currentTimeMinutes;
    qCritical() << __LINE__ << "compute_next_timestep() up/down (1=up, 0=down): " << UpDown;

    // FIXME
    //std::optional<ATBPaymentOption> paymentOption = tariff->getPaymentOptionForKey(permitType.get());
    //if (!paymentOption.has_value()) {
    //    qCritical() << "   compute_next_timestep() ERROR";
    //    return currentTimeMinutes;
    //}

    int paymentOptionIndex = getPaymentOptionIndex(*tariff);
    if (paymentOptionIndex == -1) {
        paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
    }

    int const &pop_plus_steps = tariff->getPaymentOptions(paymentOptionIndex).pop_plus_steps;
    int const &pop_minus_steps = tariff->getPaymentOptions(paymentOptionIndex).pop_minus_steps;

    qCritical() << __LINE__ << "compute_next_timestep()   payment option index: " << paymentOptionIndex;
    qCritical() << __LINE__ << "compute_next_timestep()             plus steps: " << pop_plus_steps;
    qCritical() << __LINE__ << "compute_next_timestep()            minus steps: " << pop_minus_steps;

    Configuration const *cfg = tariff;

    // compute payment method id (e.g. Linear=3, Steps=4)
    PaymentMethod const paymentMethodId = Utilities::getPaymentMethodId(cfg);
    switch (paymentMethodId) {
    case PaymentMethod::Progressive:
        qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Progressive";
        break;
    case PaymentMethod::Degressive:
        qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Degressive";
        break;
    case PaymentMethod::Linear:
        qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Linear";
        break;
    case PaymentMethod::Steps:
        qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Steps";
        break;
    case PaymentMethod::Unified:
        qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Unified";
        break;
    case PaymentMethod::Undefined:
        qCritical() << __LINE__ << "compute_next_timestep() paymentMethodId: Undefined";
        break;
    }

    // use tariff with structure as for instance Schnau, Koenigsee:
    // without given YearPeriod, SpecialDays and SpecialDaysWorktime
    if ((paymentMethodId == PaymentMethod::Steps) ||
        // progressive tariff: e.g. Neuhauser, Kirchdorf (743)
        (paymentMethodId == PaymentMethod::Progressive) ||
        // unified tariff: starting with Bad Neuenahr (249), Tariff for Zone5
        (paymentMethodId == PaymentMethod::Unified) ||
        // degressive tariff: e.g. Fuchs Technik (500)
        (paymentMethodId == PaymentMethod::Degressive))
    {
        QList<int> &stepList = Calculator::GetInstance().GetTimeSteps(tariff, paymentOptionIndex);

        int const size = stepList.size();
        if (size == 0) {
            qCritical() << "compute_next_timestep() *ERROR empty step-list*";
            return  currentTimeMinutes;
        }

        qCritical() << __LINE__ << "compute_next_timestep()      first time step:" << stepList[0];
        qCritical() << __LINE__ << "compute_next_timestep()            timeSteps:" << stepList;
        qCritical() << __LINE__ << "compute_next_timestep() currentTimeInMinutes:" << currentTimeMinutes;

        // consider time shift: the step-list might have been computed at a
        // slightly different time point

        int currentStepIndex = stepList.indexOf(currentTimeMinutes);
        if (currentStepIndex == -1) {
            unsigned minimalDistance = ~0;
            int j = -1;
            for (int i = 0; i < stepList.size(); ++i) {
                unsigned distance = std::abs(stepList[i] - currentTimeMinutes);
                if (distance < minimalDistance) {
                    minimalDistance = distance;
                    j = i;
                }
            }
            // max. tolerance set to 3 minutes
            // unsigned const tolerance = std::min(minimalDistance, (unsigned)(3));
            if (j != -1) {
                stepList[j] = currentTimeMinutes;
            }
        }

#if 0
        int maxStep = -1;
        if (size >= 2) {
            maxStep = stepList[1] - stepList[0];
        }
        // max. tolerance set to 5 minutes
        int const tolerance = (maxStep == -1) ? 5 : std::min(maxStep, 5);
        for (int i=0; i < stepList.size(); ++i) {
            if (std::abs(stepList[i] - currentTimeMinutes) <= tolerance) {
                qCritical().noquote()
                    << __LINE__ << QString("compute_next_timestep() correction stepList[%1]=%2 -> %3:")
                                    .arg(i).arg(stepList[0]).arg(currentTimeMinutes);
                stepList[i] = currentTimeMinutes;
                qCritical() << __LINE__ << "compute_next_timestep()        NEW timeSteps:" << stepList;
            }
        }

        int currentStepIndex = stepList.indexOf(currentTimeMinutes);
#endif

        currentStepIndex = stepList.indexOf(currentTimeMinutes);
        qCritical() << __LINE__ << "compute_next_timestep() currentStepIndex (" << currentStepIndex << ")";

        if (currentStepIndex == -1) {
            qCritical() << __LINE__ << "compute_next_timestep() *NO STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
            return  currentTimeMinutes;
        }

        if (UpDown == 1) { // UP
            if (stepList[currentStepIndex] == stepList.last()) {
                qCritical() << __LINE__ << "compute_next_timestep() *NO NEXT STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
                return  currentTimeMinutes;
            }
            else {
                int const rest = currentStepIndex % pop_plus_steps;

                if (rest) {
                    currentStepIndex -= rest;
                }

                qCritical() << __LINE__ << "compute_next_timestep() currentStepIndex (" << currentStepIndex << ")";

                int const nextStepIndex = currentStepIndex + pop_plus_steps;

                qCritical() << __LINE__ << "compute_next_timestep()       next step index:" << nextStepIndex;
                if (nextStepIndex >= 0 && nextStepIndex < stepList.size()) {
                    qCritical() << __LINE__ << "compute_next_timestep() return next time step:" << stepList[nextStepIndex];
                    return stepList[nextStepIndex];
                }
            }
        }
        if (UpDown == 0) { // DOWN
            if (stepList[currentStepIndex] == stepList.first()) {
                qCritical() << __LINE__ << "compute_next_timestep() *NO PREVIOUS STEP* for currentTimeMinutes (" << currentTimeMinutes << ")";
                return  currentTimeMinutes;
            }
            else {
                int const nextStepIndex = currentStepIndex - pop_minus_steps;
                qCritical() << __LINE__ << "compute_next_timestep()       next step index:" << nextStepIndex;
                if (nextStepIndex >= 0 && nextStepIndex < stepList.size()) {
                    qCritical() << __LINE__ << "compute_next_timestep() return next time step:" << stepList[nextStepIndex];
                    return stepList[nextStepIndex];
                }
            }
        }
    } else
    if (paymentMethodId == PaymentMethod::Linear) {

        // currentTimeMinutes is the number of minutes actually used. This
        // value is an offset from the start time and cannot be used as a
        // QDateTime.

        qCritical() << "compute_next_timestep() up/down (1=up, 0=down):" << UpDown;

        // get minimal and maximal parking times
        int const minParkingTime = Utilities::getMinimalParkingTime(cfg, paymentMethodId);
        int const maxParkingTime = Utilities::getMaximalParkingTime(cfg, paymentMethodId);

        qCritical() << "        compute_next_timestep() maxParkingTime:" << maxParkingTime;
        qCritical() << "        compute_next_timestep() minParkingTime:" << minParkingTime;

        // use the first (i.e. main duration step contained in the tariff json-file)
        int firstDurationStep = Utilities::getFirstDurationStep(cfg, paymentMethodId);
        firstDurationStep = ((UpDown == 1) ? firstDurationStep : -firstDurationStep);

        qCritical() << "     compute_next_timestep() firstDurationStep:" << firstDurationStep;

        int const nextTimeStep = currentTimeMinutes + firstDurationStep;

        if (nextTimeStep >= minParkingTime && nextTimeStep <= maxParkingTime) {
            qCritical() << "          compute_next_timestep() nextTimeStep:" << nextTimeStep;
            return nextTimeStep;
        }
    }

    qCritical() << "compute_next_timestep() *CAN NOT COMPUTE* for currentTimeMinutes (" << currentTimeMinutes << ")";
    return  currentTimeMinutes;
}

// this is currently not used
CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
        parking_tariff_t *tariff,
        time_t start_parking_time,  // in minutes
        time_t end_parking_time,    // netto time in minutes
        struct price_t *price,
        PermitType permitType) {    // permitType maps to product

    CalcState calcState;

    QDate const d(1970, 1, 1);
    QTime const t(0, 0, 0);
    QDateTime start(d, t, Qt::UTC);
    start = start.toLocalTime().addSecs(start_parking_time * 60);
    QDateTime end(start);

    int paymentOptionIndex = getPaymentOptionIndex(*tariff, start);
    if (paymentOptionIndex == -1) {
        paymentOptionIndex = tariff->getPaymentOptionIndex(permitType.get());
    }

    tariff->getPaymentOptions(paymentOptionIndex).pop_max_price
        = tariff->getPaymentOptions(paymentOptionIndex).pop_max_price_save;

    double minMin = tariff->PaymentOption.find(tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id)->second.pop_min_time;
    double maxMin = tariff->PaymentOption.find(tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id)->second.pop_max_time;

    if (minMin < 0 || maxMin < 0 || maxMin < minMin) {
        calcState.setDesc(QString("minMin=%1, maxMin=%2").arg(minMin).arg(maxMin));
        return calcState.set(CalcState::State::WRONG_PARAM_VALUES);
    }

    int const duration = end_parking_time - start_parking_time;
    if (duration < 0) {
        calcState.setDesc(QString("end=%1, start=%2")
                          .arg(end_parking_time, start_parking_time));
        return calcState.set(CalcState::State::NEGATIVE_PARKING_TIME);
    }
    if (duration > maxMin) {
        calcState.setDesc(QString("duration=%1, maxMin=%2").arg(duration).arg(maxMin));
        return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
    }
    if (duration < minMin) {
        calcState.setDesc(QString("duration=%1, minMin=%2").arg(duration).arg(minMin));
        return calcState.set(CalcState::State::BELOW_MIN_PARKING_TIME);
    }
    if (duration == 0) {
        return calcState.set(CalcState::State::SUCCESS);
    }

    //QDate const d(1970, 1, 1);
    //QTime const t(0, 0, 0);
    //QDateTime start(d, t, Qt::UTC);
    //start = start.toLocalTime().addSecs(start_parking_time * 60);
    //QDateTime end(start);
    if (start.isValid()) {
        double cost = Calculator::GetInstance().GetCostFromDuration(
                    tariff,
                    tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id,
                    start,
                    end,
                    duration, false, true);
        double minCost = tariff->PaymentOption.find(tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id)->second.pop_min_price;
        if (cost < minCost) {
            calcState.setDesc(QString("line=%1 minCost=%2, cost=%3").arg(__LINE__).arg(minCost).arg(cost));
            return calcState.set(CalcState::State::BELOW_MIN_PARKING_PRICE);
        }
        price->units = cost;
        price->netto = cost;
    } else {
        return calcState.set(CalcState::State::INVALID_START_DATE);
    }

    return calcState.set(CalcState::State::SUCCESS);
}

CalcState CALCULATE_LIBRARY_API compute_price_for_parking_ticket(
        parking_tariff_t *tariff,
        QDateTime &start_parking_time_,
        int netto_parking_time,
        QDateTime &end_parking_time,
        struct price_t *price,
        PermitType permitType,
        bool prepaid)
{
    CalcState calcState;

    QDateTime start_parking_time(start_parking_time_);

    int paymentOptionIndex = getPaymentOptionIndex(*tariff, start_parking_time);
    if (paymentOptionIndex == -1) {
        paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
    }

    tariff->getPaymentOptions(paymentOptionIndex).pop_max_price
        = tariff->getPaymentOptions(paymentOptionIndex).pop_max_price_save;

    double minMin = tariff->getPaymentOptions(paymentOptionIndex).pop_min_time;
    double maxMin = tariff->getPaymentOptions(paymentOptionIndex).pop_max_time;

    // DEBUG
    qCritical() << "compute_price_for_parking_ticket() " << endl
                << "          paymentOptionIndex: " << paymentOptionIndex << endl
                << "          start_parking_time: " << start_parking_time << endl
                << "          netto_parking_time: " << netto_parking_time << endl
                << "               start + netto: " << start_parking_time.addSecs(netto_parking_time * 60) << endl
                << "                      minMin: " << minMin << endl
                << "                      maxMin: " << maxMin
                << "                     prepaid: " << prepaid
                << "                  permitType: " << permitType.toString();

    if (netto_parking_time < 0) {
        calcState.setDesc(QString("end=%1, start=%2")
                          .arg(end_parking_time.toString(Qt::ISODate),
                               start_parking_time.toString(Qt::ISODate)));
        return calcState.set(CalcState::State::NEGATIVE_PARKING_TIME);
    }
    if (netto_parking_time > maxMin) {
        calcState.setDesc(QString("duration=%1, maxMin=%2").arg(netto_parking_time).arg(maxMin));
        return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
    }
    if (netto_parking_time < minMin) {
        calcState.setDesc(QString("duration=%1, minMin=%2").arg(netto_parking_time).arg(minMin));
        return calcState.set(CalcState::State::BELOW_MIN_PARKING_TIME);
    }
    if (netto_parking_time == 0) {
        return calcState.set(CalcState::State::SUCCESS);
    }

    double cost = -1;
    if (start_parking_time.isValid()) {
        if (tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id == PaymentMethod::Steps ||
            tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id == PaymentMethod::Degressive) {
            // hier muesste man unterscheiden: uebertrag oder nicht?
            calcState = Calculator::GetInstance().isParkingAllowed(tariff, start_parking_time,
                                                                   netto_parking_time, paymentOptionIndex);
            if (calcState.getStatus() == CalcState::State::OUTSIDE_ALLOWED_PARKING_TIME) {
                qCritical() << "(" << __func__ << ":" << __LINE__ << ")"
                            << calcState.toString();
                return calcState;
            }

            QList<int> tlist = Calculator::GetInstance().GetTimeSteps(tariff);
            Q_UNUSED(tlist);

            // compute cost (price)
            cost = Calculator::GetInstance().GetCostFromDuration(tariff, start_parking_time, netto_parking_time, paymentOptionIndex);

            int weekDay = start_parking_time.date().dayOfWeek();
            int pop_carry_over_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over_option_id;
            int pop_prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;

            std::optional<ATBPeriodYear> yperiod = Utilities::GetYearPeriodActive(tariff, start_parking_time);
            int period_id = -1;
            if (yperiod.has_value()) {
                ATBPeriodYear const &period = yperiod.value();
                period_id = period.pye_id;
                pop_carry_over_option_id = period.pye_id;
                pop_prepaid_option_id = period.pye_id;
                qCritical() << __func__ << ":" << __LINE__ << "re-computed carry-over-id" << pop_carry_over_option_id;
                qCritical() << __func__ << ":" << __LINE__ << "   re-computed prepaid-id" << pop_prepaid_option_id;
            }

            QTime carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
            int carryOverDuration = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;

            qCritical() << __func__ << ":" << __LINE__ << "   carryOverStart" << carryOverStart.toString(Qt::ISODate);
            qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;


            QDateTime effectiveStartTime(start_parking_time);

            // handle special days
            int const specialDayId = tariff->specialDayId(start_parking_time);
            if (specialDayId > 0) { // found special day
                for (auto[itr, rangeEnd] = tariff->SpecialDaysWorktime.equal_range(specialDayId); itr != rangeEnd; ++itr) {
                    ATBSpecialDaysWorktime const &wt = itr->second;
                    switch(period_id) {
                    case 1: // summer term
                        if ((wt.pedwt_paid & 1) == 0) {
                            // does not have to be paid, move to next midnight

                            // better: start of next day (falls kein vorkauf besteht)
                            effectiveStartTime = effectiveStartTime.addDays(1);
                            effectiveStartTime.setTime(QTime(0, 0, 0));
                        }
                        break;
                    case 2: // winter term
                        if ((wt.pedwt_paid & 2) == 0) {
                            // does not have to be paid, move to next midnight

                            // better: start of next day (falls kein vorkauf besteht)
                            effectiveStartTime = effectiveStartTime.addDays(1);
                            effectiveStartTime.setTime(QTime(0, 0, 0));
                        }
                        break;
                    default:;
                    }
                }
            }

            // handle prepaid option
            int const prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
            std::optional<ATBPrepaid> prepaidOption = tariff->getPrepaidType(prepaid_option_id);
            if (prepaidOption.has_value()) {
                ATBPrepaid const &p = prepaidOption.value();
                if (p.never) {
                    qCritical() << __func__ << ":" << __LINE__ << "prepaid: no";
                } else {
                    qCritical() << __func__ << ":" << __LINE__ << "    prepaidStart" << p.prepaid[weekDay].static_start.toString(Qt::ISODate);
                    qCritical() << __func__ << ":" << __LINE__ << "      prepaidEnd" << p.prepaid[weekDay].static_end.toString(Qt::ISODate);
                    qCritical() << __func__ << ":" << __LINE__ << "prepaid duration" << p.prepaid[weekDay].duration;

                    if (start_parking_time.time() < p.prepaid[weekDay].static_end) {     // static_end: e.g. 08:00:00
                        effectiveStartTime.setTime(p.prepaid[weekDay].static_end);
                    } else
                    if (start_parking_time.time() > p.prepaid[weekDay].static_start) {   // static_start: e.g. 22:00:00
                        effectiveStartTime.setTime(p.prepaid[weekDay].static_start);
                    }
                }
            }

            effectiveStartTime.setTime(QTime(effectiveStartTime.time().hour(),
                                             effectiveStartTime.time().minute(), 0));

            qCritical() << __func__ << ":" << __LINE__ << "effectiveStartTime:" << effectiveStartTime.toString(Qt::ISODate);

            int const carryOver = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over;

            qCritical() << __func__ << ":" << __LINE__ << "   carryOver flag" << carryOver;

            if (carryOver == 1) {
                QTime carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
                int carryOverDuration = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;

                qCritical() << __func__ << ":" << __LINE__ << "   carryOverStart" << carryOverStart.toString(Qt::ISODate);
                qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;

                // handle carry over
                int minutesUntilCarryOver = effectiveStartTime.time().secsTo(carryOverStart) / 60;
                if ((minutesUntilCarryOver > 0) && (netto_parking_time > minutesUntilCarryOver)) {
                    int const rest = netto_parking_time - minutesUntilCarryOver;
                    QDateTime s(effectiveStartTime);
                    s = s.addSecs(minutesUntilCarryOver * 60);
                    s = s.addSecs(carryOverDuration * 60);
                    end_parking_time = s.addSecs(rest * 60);
                } else {
                    end_parking_time = effectiveStartTime.addSecs(netto_parking_time*60);
                }

                qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);

                weekDay = end_parking_time.date().dayOfWeek();

                // musste man in einer schleife machen
                carryOverStart = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].static_start;
                carryOverDuration = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)->second.carryover[weekDay].duration;

                if (end_parking_time.time() > carryOverStart) {
                    end_parking_time = end_parking_time.addSecs(carryOverDuration * 60);
                } else
                if (end_parking_time.time() == carryOverStart) {
                    qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
                    qCritical() << __func__ << ":" << __LINE__ << "   carryOverStart" << carryOverStart.toString(Qt::ISODate);
                    ATBPaymentOption const &po = tariff->getPaymentOptions(paymentOptionIndex);
                    if (po.pop_apply_carry_over_to_ticket_endtime) {
                        end_parking_time = end_parking_time.addSecs(carryOverDuration * 60);
                        qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
                    }
                }
            } else {
                qCritical() << __func__ << ":" << __LINE__ << "NO carryOver configured";
                end_parking_time = effectiveStartTime.addSecs(netto_parking_time*60);
            }

            end_parking_time.setTime(QTime(end_parking_time.time().hour(),
                                           end_parking_time.time().minute(), 0));

            qCritical() << __func__ << ":" << __LINE__ << "end-parking-time:" << end_parking_time.toString(Qt::ISODate);
            qCritical() << __func__ << ":" << __LINE__ << "        week-day:" << weekDay;

            for (auto[itr, rangeEnd] = tariff->WeekDays.equal_range((Qt::DayOfWeek)weekDay); itr != rangeEnd; ++itr) {
                ATBWeekDay const &wd = itr->second;
                bool const parkTimeLimitViolated = wd.getTariffCarryOverSettings().parkingTimeLimitExceeded(effectiveStartTime,
                                                                                                            end_parking_time,
                                                                                                            paymentOptionIndex);
                if (parkTimeLimitViolated) {
                    //QTime const &tlimit = wd.getTariffCarryOverSettings().parkingTimeLimit();
                    //end_parking_time.setTime(tlimit);

                    // max_price neu berechnen

                    calcState.setDesc(QString("line=%1 endTime=%2: park-time-limit violated").arg(__LINE__)
                                        .arg(end_parking_time.time().toString(Qt::ISODate)));
                    return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
                }
            }
        } else
        if (tariff->getPaymentOptions(0).pop_payment_method_id == PaymentMethod::Unified) {
            std::pair<CalcState, std::optional<int>> p =
                Calculator::GetInstance().ComputeCostFromDuration(tariff, start_parking_time, end_parking_time, netto_parking_time);
            CalcState const cs = p.first;

            if ((cs.getStatus() == CalcState::State::SUCCESS || cs.getStatus() == CalcState::State::SUCCESS_MAXPRICE)) {
                if (p.second.has_value()) {
                    cost = p.second.value();
                }
            } else {
                return cs;
            }
        } else {
            cost = Calculator::GetInstance().GetCostFromDuration(
                        tariff,
                        tariff->getPaymentOptions().pop_payment_method_id,
                        start_parking_time,         // starting time
                        end_parking_time,           // return value: end time
                        netto_parking_time,         // minutes, netto
                        false, prepaid);
        }

        double minCost = tariff->getPaymentOptions(paymentOptionIndex).pop_min_price;
        if (cost < minCost) {
            calcState.setDesc(QString("line=%1 minCost=%2, cost=%3").arg(__LINE__).arg(minCost).arg(cost));
            return calcState.set(CalcState::State::BELOW_MIN_PARKING_PRICE);
        }

        // DEBUG
        //qCritical() << __LINE__ << "            end_parking_time: " << end_parking_time;
        //qCritical() << __LINE__ << "  -> calculated cost (netto): " << cost;

        price->brutto = price->vat = price->vat_percentage = 0;
        price->units = cost;
        price->netto = cost;

    } else {
        return calcState.set(CalcState::State::INVALID_START_DATE);
    }

    if (end_parking_time.time().hour() == 0 && end_parking_time.time().minute() == 0) {
        end_parking_time = end_parking_time.addDays(-1);
        end_parking_time.setTime(QTime(23, 59, 0));
    }
    qCritical() << __func__ << __LINE__ << "end_parking_time" << end_parking_time.toString(Qt::ISODate);

    return calcState.set(CalcState::State::SUCCESS);
}

CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
        parking_tariff_t *tariff,
        time_t start_parking_time,
        double price,
        QString &duration,
        PermitType permitType) {
    CalcState calcState;
    QDate const d(1970, 1, 1);
    QTime const t(0, 0, 0);
    QDateTime start(d, t, Qt::UTC);
    start = start.toLocalTime().addSecs(start_parking_time * 60);
    if (start.isValid()) {
        QString cs = start.toString(Qt::ISODate);

        bool prepaid = true;
        int paymentOptionIndex = getPaymentOptionIndex(*tariff, start);
        qCritical() << " payment option index: " << paymentOptionIndex;
        if (paymentOptionIndex == -1) {
            paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
        }

        int prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
        if (prepaid_option_id == 2) { // see tariff03.json for 502: 2 means no prepaid-option
            prepaid = false;
        }
        bool const nextDay = false;

        // DEBUG
        qCritical() << "compute_duration_for_parking_ticket(1): ";
        qCritical() << " payment option index: " << paymentOptionIndex;
        qCritical() << "              prepaid: " << prepaid;
        qCritical() << "           start (cs): " << cs;
        qCritical() << "                price: " << price;

        std::pair<std::string, QDateTime> p_duration
                = Calculator::GetInstance().GetDurationFromCost(tariff,
                    tariff->getPaymentOptions(paymentOptionIndex).pop_payment_method_id,
                                              cs.toLocal8Bit().constData(),
                                              price, permitType, nextDay, prepaid);
        duration = p_duration.first.c_str();


        QDateTime d = QDateTime::fromString(duration, Qt::ISODate);
        if (!d.isValid()) {
            calcState.setDesc(QString("ticketEndTime=%1").arg(duration));
            return calcState.set(CalcState::State::WRONG_ISO_TIME_FORMAT);
        }
    } else {
        return calcState.set(CalcState::State::INVALID_START_DATE);
    }

    return calcState.set(CalcState::State::SUCCESS);
}

CalcState CALCULATE_LIBRARY_API compute_duration_for_parking_ticket(
        parking_tariff_t *tariff,
        QDateTime const &start_parking_time,
        double price,
        QDateTime &ticketEndTime,
        PermitType permitType)
{
    CalcState calcState;

    bool prepaid = true;

    int paymentOptionIndex = getPaymentOptionIndex(*tariff, start_parking_time);
    qCritical() << __func__ << ":" << __LINE__ << "payment option index: " << paymentOptionIndex;
    if (paymentOptionIndex == -1) {
        paymentOptionIndex = tariff->getPaymentOptionIndex(permitType);
    }

    qCritical() << __func__ << ":" << __LINE__ << " payment option index: " << paymentOptionIndex;

    int prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;

    if (prepaid_option_id == 2) {
        prepaid = false;
    }
    bool const nextDay = false;

    // DEBUG
    if (DBG_LEVEL >= DBG_DEBUG) {
        qCritical() << "compute_duration_for_parking_ticket(2): ";
        qCritical() << " payment option index: " << paymentOptionIndex;
        qCritical() << "              prepaid: " << prepaid;
        qCritical() << "                price: " << price;
    }

    if (start_parking_time.isValid()) {

        int const pop_time_step_config = tariff->getPaymentOptions(paymentOptionIndex).pop_time_step_config;
        if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::STATIC) {
            // handle prepaid option
            QDateTime effectiveStartTime(start_parking_time);

            effectiveStartTime.setTime(QTime(effectiveStartTime.time().hour(),
                                             effectiveStartTime.time().minute(), 0));

            int const prepaid_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_prepaid_option_id;
            std::optional<ATBPrepaid> prepaidOption = tariff->getPrepaidType(prepaid_option_id);
            if (prepaidOption.has_value()) {
                ATBPrepaid const &p = prepaidOption.value();
                if (p.never) {
                    qCritical() << __func__ << __LINE__ << "prepaid: no";
                } else {
                    if (start_parking_time.time() < p.static_end) {     // static_end: e.g. 08:00:00
                        effectiveStartTime.setTime(p.static_end);
                    } else
                    if (start_parking_time.time() > p.static_start) {   // static_start: e.g. 22:00:00
                        effectiveStartTime.setTime(p.static_start);
                    }
                }
            }
        }
        QDateTime start(start_parking_time);
        start.setTime(QTime(start.time().hour(), start.time().minute(), 0));
        QString cs = start.toString(Qt::ISODate);

        std::pair<std::string, QDateTime> p_endTime
                = Calculator::GetInstance().GetDurationFromCost(
                    tariff,
                    tariff->getPaymentOptions().pop_payment_method_id,
                    cs.toLocal8Bit().constData(),
                    price, permitType, nextDay, prepaid);

        QString endTime = p_endTime.first.c_str();
        ticketEndTime = p_endTime.second;

        qCritical() << __func__ << ":" << __LINE__ << endTime;
        qCritical() << __func__ << ":" << __LINE__ << ticketEndTime.toString(Qt::ISODate);

        if (endTime == CalcState::SUCCESS) {
            calcState.setDesc(QString("SUCCESS"));
            calcState.setStatus(endTime);
            qCritical() << __func__ << ":" << __LINE__ << "SUCCESS";
        } else
        if (endTime == CalcState::SUCCESS_MAXPRICE) {
            calcState.setDesc(QString("SUCCESS_MAXPRICE"));
            calcState.setStatus(endTime);
            qCritical() << __func__ << ":" << __LINE__ << "SUCCESS_MAXPRICE";
        } else
        if (endTime == CalcState::ERROR_PARSING_ZONE_NR) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::ERROR_LOADING_TARIFF) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::ERROR_PARSING_TARIFF) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::NEGATIVE_PARKING_TIME) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::INVALID_START_DATE) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::WRONG_PARAM_VALUES) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::WRONG_ISO_TIME_FORMAT) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::ABOVE_MAX_PARKING_TIME) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::BELOW_MIN_PARKING_TIME) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::BELOW_MIN_PARKING_PRICE) {
            calcState.setStatus(endTime);
            return calcState;
        } else
        if (endTime == CalcState::ABOVE_MAX_PARKING_PRICE) {
            calcState.setDesc(CalcState::ABOVE_MAX_PARKING_PRICE);
            calcState.setStatus(CalcState::ABOVE_MAX_PARKING_PRICE);
            return calcState;
        } else
        if (endTime == CalcState::OVERPAID) {
            calcState.setDesc(CalcState::OVERPAID);
            calcState.setStatus(CalcState::OVERPAID);
            return calcState;
        } else
        if (endTime == CalcState::OUTSIDE_ALLOWED_PARKING_TIME) {
            calcState.setStatus(endTime);
            return calcState;
        } else {
            ticketEndTime = QDateTime::fromString(endTime,Qt::ISODate);

            ticketEndTime.setTime(QTime(ticketEndTime.time().hour(),
                                        ticketEndTime.time().minute(), 0));

            int netto_parking_time = start_parking_time.secsTo(ticketEndTime) / 60;

            qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);
            qCritical() << __func__ << ":" << __LINE__ << "step-config:" << pop_time_step_config;
            qCritical() << __func__ << ":" << __LINE__ << "netto-parking-time" << netto_parking_time;

            if (!ticketEndTime.isValid()) {
                calcState.setDesc(QString("ticketEndTime=%1").arg(endTime));
                return calcState.set(CalcState::State::WRONG_ISO_TIME_FORMAT);
            }

            if (tariff->getPaymentOptions().pop_payment_method_id != PaymentMethod::Unified) {

                if (pop_time_step_config == (int)ATBTimeStepConfig::TimeStepConfig::STATIC) {
                    // handle carry over for ticket-end-time
                    qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);

                    int weekDay = start_parking_time.date().dayOfWeek();
                    int pop_carry_over_option_id = tariff->getPaymentOptions(paymentOptionIndex).pop_carry_over_option_id;
                    qCritical() << __func__ << ":" << __LINE__ << "configured carry-over-id" << pop_carry_over_option_id;

                    std::optional<ATBPeriodYear> yperiod = Utilities::GetYearPeriodActive(tariff, start_parking_time);
                    if (yperiod.has_value()) {
                        ATBPeriodYear const &period = yperiod.value();
                        pop_carry_over_option_id = period.pye_id;
                        qCritical() << __func__ << ":" << __LINE__ << "re-computed carry-over-id" << pop_carry_over_option_id;
                    }

                    QTime carryOverStart;
                    QTime carryOverEnd;
                    int carryOverDuration = -1;

                    // using TariffCarryOverType = std::multimap<int, ATBCarryOver>;
                    std::multimap<int, ATBCarryOver>::const_iterator it;
                    if ((it = tariff->TariffCarryOverOptions.find(pop_carry_over_option_id)) !=
                        tariff->TariffCarryOverOptions.cend()) {
                        carryOverStart = it->second.carryover[weekDay].static_start;
                        carryOverEnd = it->second.carryover[weekDay].static_end;
                        carryOverDuration = it->second.carryover[weekDay].duration;
                    }

                    if (carryOverStart.isValid() && carryOverEnd.isValid()) {
                        qCritical() << __func__ << ":" << __LINE__ << "carryOverStart" << carryOverStart.toString(Qt::ISODate);
                        qCritical() << __func__ << ":" << __LINE__ << "carryOverEnd" << carryOverEnd.toString(Qt::ISODate);
                        qCritical() << __func__ << ":" << __LINE__ << "carryOverDuration" << carryOverDuration;
                    }

                    if (carryOverStart.isValid() && carryOverEnd.isValid() && carryOverDuration != -1) {

                        // note: in such a case (direct coins) carry-over has been handled
                        // already in GetDurationFromCost()
                        netto_parking_time -= carryOverDuration;
                        qCritical() << __func__ << ":" << __LINE__ << "netto-parking-time" << netto_parking_time;

                        // qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
                        if (ticketEndTime.time() > carryOverStart) {
                            // qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
                            ticketEndTime = ticketEndTime.addSecs(carryOverDuration * 60);
                        } else
                        if (ticketEndTime.time() == carryOverStart) {
                            qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
                            qCritical() << __func__ << ":" << __LINE__ << "   carryOverStart" << carryOverStart.toString(Qt::ISODate);
                            ATBPaymentOption const &po = tariff->getPaymentOptions(paymentOptionIndex);
                            if (po.pop_apply_carry_over_to_ticket_endtime) {
                                ticketEndTime = ticketEndTime.addSecs(carryOverDuration * 60);
                                qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
                            }
                        } else {
                            // qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
                            if (ticketEndTime.time() < carryOverEnd) {
                                // qCritical() << __func__ << __LINE__ << "ticketEndTime.time():" << ticketEndTime.time().toString(Qt::ISODate);
                                ticketEndTime = ticketEndTime.addSecs(carryOverDuration * 60);
                            }
                        }
                    } else {
                        qCritical() << __func__ << ":" << __LINE__ << "WARNING: wrong carry-over-settings";
                    }
                }

                qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);

                for (auto[itr, rangeEnd] = tariff->WeekDays.equal_range((Qt::DayOfWeek)(ticketEndTime.date().dayOfWeek()));
                     itr != rangeEnd;
                     ++itr) {
                    ATBWeekDay const &wd = itr->second;
                    bool parkTimeLimitViolated = wd.getTariffCarryOverSettings().parkingTimeLimitExceeded(start_parking_time,
                                                                                                          ticketEndTime,
                                                                                                          paymentOptionIndex);
                    if (parkTimeLimitViolated) {
                        //QTime const &tlimit = wd.getTariffCarryOverSettings().parkingTimeLimit();
                        //ticketEndTime.setTime(tlimit);

                        QList<int> const &stepList = Calculator::GetInstance().GetTimeSteps(tariff, paymentOptionIndex);

                        QDateTime newTicketEndTime = ticketEndTime;

                        qCritical() << __func__ << ":" << __LINE__ << "PARK-TIME VIOLATED";

                        for (int i = stepList.size() - 1; i > 0; --i) {
                            // qCritical() << __func__ << ":" << __LINE__ << "step[" << i << "]" << stepList.at(i);

                            if (netto_parking_time > 0 && stepList.at(i) <= netto_parking_time) {
                                int const diff = stepList.at(i-1) - stepList.at(i);
                                newTicketEndTime = newTicketEndTime.addSecs(diff * 60);

                                // qCritical() << __func__ << ":" << __LINE__ << "new-ticket-end-time" << newTicketEndTime.toString(Qt::ISODate);

                                parkTimeLimitViolated
                                    = wd.getTariffCarryOverSettings()
                                        .parkingTimeLimitExceeded(start_parking_time, newTicketEndTime, paymentOptionIndex);

                                if (!parkTimeLimitViolated) {

                                    qCritical() << __func__ << ":" << __LINE__
                                                << "PARK-TIME NOT VIOLATED FOR" << newTicketEndTime.toString(Qt::ISODate);

                                    int duration = stepList.at(i-1);

                                    // qCritical() << __func__ << ":" << __LINE__ << "duration" << duration;

                                    std::multimap<int, ATBDuration>::const_iterator it;
                                    for (it = tariff->Duration.cbegin();
                                         it != tariff->Duration.cend();
                                         ++it) {
                                        if (duration == it->second.pun_duration) {

                                            // qCritical() << __func__ << ":" << __LINE__ << "duration" << duration;

                                            ATBPaymentOption &po = tariff->getPaymentOptions(paymentOptionIndex);
                                            int const pop_id = po.pop_id;
                                            for (auto[itr, rangeEnd] = tariff->PaymentRate.equal_range(pop_id); itr != rangeEnd; ++itr) {
                                                int const durationId = itr->second.pra_payment_unit_id;

                                                // qCritical() << __func__ << ":" << __LINE__ << "durationId" << durationId << it->second.pun_id;

                                                // note: for this to work, Duration and PaymentRate must have
                                                // exactly the same structure
                                                if (durationId == it->second.pun_id) {
                                                    int const pra_price = itr->second.pra_price;
                                                    po.pop_max_price = pra_price;

                                                    qCritical() << __func__ << ":" << __LINE__ << "new max-price" << po.pop_max_price;

                                                    // note: ABOVE_MAX_PARKING_TIME would also be possible
                                                    // but here max-parking-time is dynamic. And for
                                                    // this dynamic value, opverpaid is actually correct

                                                    calcState.setDesc(CalcState::OVERPAID);
                                                    calcState.setStatus(CalcState::OVERPAID);
                                                    return calcState;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        calcState.setDesc(QString("line=%1 endTime=%2: park-time-limit violated").arg(__LINE__)
                                          .arg(ticketEndTime.time().toString(Qt::ISODate)));
                        return calcState.set(CalcState::State::ABOVE_MAX_PARKING_TIME);
                    }
                }
            }

            if (ticketEndTime.time().hour() == 0 && ticketEndTime.time().minute() == 0) {
                ticketEndTime = ticketEndTime.addDays(-1);
                ticketEndTime.setTime(QTime(23, 59, 0));
            }

            // DEBUG
            qCritical() << __func__ << ":" << __LINE__ << "      endTime:" << endTime;
            qCritical() << __func__ << ":" << __LINE__ << "ticketEndTime:" << ticketEndTime.toString(Qt::ISODate);
        }
    } else {
        return calcState.set(CalcState::State::INVALID_START_DATE);
    }

    //return calcState.set(CalcState::State::SUCCESS);
    qCritical() << __func__ << ":" << __LINE__ << "  calcState" << calcState.toString();
    return calcState;
}

CalcState CALCULATE_LIBRARY_API compute_duration_for_daily_ticket(parking_tariff_t *tariff,
                                                                  QDateTime const &start_parking_time,
                                                                  QDateTime &ticketEndTime,
                                                                  PermitType /* PermitType */)
{
    CalcState calcState;
    if (start_parking_time.isValid()) {

        ticketEndTime = Calculator::GetInstance().GetDailyTicketDuration(tariff,
                                                            start_parking_time,
                                                            tariff->getPaymentOptions().pop_payment_method_id,
                                                            false);    // carry over

        // DEBUG
        qCritical() << "compute_duration_for_daily_ticket(): ";
        qCritical() << "           ticketEndTime: " << ticketEndTime;

        if (!ticketEndTime.isValid()) {
            calcState.setDesc(QString("ticketEndTime=%1").arg(ticketEndTime.toString(Qt::ISODate)));
            return calcState.set(CalcState::State::WRONG_ISO_TIME_FORMAT);
        }

    } else {
        return calcState.set(CalcState::State::INVALID_START_DATE);
    }

    return calcState.set(CalcState::State::SUCCESS);
}


CalcState CALCULATE_LIBRARY_API compute_price_for_daily_ticket(
                                    parking_tariff_t *tariff,
                                    QDateTime const &startDatetime,
                                    QDateTime &endDatetime,
                                    PERMIT_TYPE permitType,
                                    struct price_t *price) {// return value
    CalcState calcState;


    if (startDatetime.isValid()) {
        if (std::optional<struct price_t> p =
            Calculator::GetInstance().GetDailyTicketPrice(tariff,
                                                          startDatetime,
                                                          endDatetime,
                                                          permitType)) {
           *price = p.value();
        }
    } else {
        return calcState.set(CalcState::State::INVALID_START_DATE);
    }
    return calcState.set(CalcState::State::SUCCESS);
}