#include "fesa/core/AnalysisState.hpp"

#include <stdexcept>
#include <vector>

namespace {

int require(bool condition) {
    return condition ? 0 : 1;
}

template <typename Exception, typename Function>
int require_throws(Function&& function) {
    try {
        function();
    } catch (const Exception&) {
        return 0;
    } catch (...) {
        return 1;
    }
    return 1;
}

int default_state_has_no_dofs() {
    const fesa::core::AnalysisState state;

    if (const int result = require(state.dofCount() == 0); result != 0) {
        return result;
    }
    if (const int result = require(state.displacement().empty()); result != 0) {
        return result;
    }
    if (const int result = require(state.externalForce().empty()); result != 0) {
        return result;
    }
    if (const int result = require(state.internalForce().empty()); result != 0) {
        return result;
    }
    if (const int result = require(state.residual().empty()); result != 0) {
        return result;
    }
    return require(state.reaction().empty());
}

int sized_state_initializes_zero_vectors() {
    const fesa::core::AnalysisState state{3};

    if (const int result = require(state.dofCount() == 3); result != 0) {
        return result;
    }
    for (const auto* vector : {
             &state.displacement(),
             &state.externalForce(),
             &state.internalForce(),
             &state.residual(),
             &state.reaction(),
         }) {
        if (const int result = require(vector->size() == state.dofCount()); result != 0) {
            return result;
        }
        for (const double value : *vector) {
            if (const int result = require(value == 0.0); result != 0) {
                return result;
            }
        }
    }
    return 0;
}

int setters_replace_matching_size_vectors() {
    fesa::core::AnalysisState state{2};

    state.setDisplacement({1.0, 2.0});
    state.setExternalForce({3.0, 4.0});
    state.setInternalForce({5.0, 6.0});
    state.setResidual({7.0, 8.0});
    state.setReaction({9.0, 10.0});

    if (const int result = require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0); result != 0) {
        return result;
    }
    if (const int result = require(state.externalForce()[0] == 3.0 && state.externalForce()[1] == 4.0); result != 0) {
        return result;
    }
    if (const int result = require(state.internalForce()[0] == 5.0 && state.internalForce()[1] == 6.0); result != 0) {
        return result;
    }
    if (const int result = require(state.residual()[0] == 7.0 && state.residual()[1] == 8.0); result != 0) {
        return result;
    }
    return require(state.reaction()[0] == 9.0 && state.reaction()[1] == 10.0);
}

int mismatched_setter_preserves_existing_vector() {
    fesa::core::AnalysisState state{2};
    state.setDisplacement({1.0, 2.0});

    if (const int result = require_throws<std::invalid_argument>([&state]() {
            state.setDisplacement({3.0});
        });
        result != 0) {
        return result;
    }

    return require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0);
}

int resize_resets_all_vectors_to_zero() {
    fesa::core::AnalysisState state{2};
    state.setDisplacement({1.0, 2.0});
    state.setExternalForce({3.0, 4.0});

    state.resize(3);

    if (const int result = require(state.dofCount() == 3); result != 0) {
        return result;
    }
    for (const auto* vector : {
             &state.displacement(),
             &state.externalForce(),
             &state.internalForce(),
             &state.residual(),
             &state.reaction(),
         }) {
        for (const double value : *vector) {
            if (const int result = require(value == 0.0); result != 0) {
                return result;
            }
        }
    }
    return 0;
}

int clear_forces_preserves_displacement() {
    fesa::core::AnalysisState state{2};
    state.setDisplacement({1.0, 2.0});
    state.setExternalForce({3.0, 4.0});
    state.setInternalForce({5.0, 6.0});
    state.setResidual({7.0, 8.0});
    state.setReaction({9.0, 10.0});

    state.clearForces();

    if (const int result = require(state.displacement()[0] == 1.0 && state.displacement()[1] == 2.0); result != 0) {
        return result;
    }
    for (const auto* vector : {
             &state.externalForce(),
             &state.internalForce(),
             &state.residual(),
             &state.reaction(),
         }) {
        for (const double value : *vector) {
            if (const int result = require(value == 0.0); result != 0) {
                return result;
            }
        }
    }
    return 0;
}

int counters_can_be_updated() {
    fesa::core::AnalysisState state;

    state.setCurrentTime(1.25);
    state.setIncrementIndex(3);
    state.setIterationIndex(5);

    if (const int result = require(state.currentTime() == 1.25); result != 0) {
        return result;
    }
    if (const int result = require(state.incrementIndex() == 3); result != 0) {
        return result;
    }
    return require(state.iterationIndex() == 5);
}

} // namespace

int run_analysis_state_tests() {
    if (const int result = default_state_has_no_dofs(); result != 0) {
        return result;
    }
    if (const int result = sized_state_initializes_zero_vectors(); result != 0) {
        return result;
    }
    if (const int result = setters_replace_matching_size_vectors(); result != 0) {
        return result;
    }
    if (const int result = mismatched_setter_preserves_existing_vector(); result != 0) {
        return result;
    }
    if (const int result = resize_resets_all_vectors_to_zero(); result != 0) {
        return result;
    }
    if (const int result = clear_forces_preserves_displacement(); result != 0) {
        return result;
    }
    if (const int result = counters_can_be_updated(); result != 0) {
        return result;
    }
    return 0;
}