/*------------------------------------------------------------------------------
 *	Copyright (c) 2023 by Bai Bing (seread@163.com)
 *	See COPYING file for copying and redistribution conditions.
 *
 *  Alians IT Studio.
 *----------------------------------------------------------------------------*/
#pragma once

#include <algorithm>
#include <any>
#include <array>
#include <chrono>
#include <list>
#include <memory>
#include <numeric>
#include <queue>
#include <utility>
#include <vector>
#include <stdexcept>
#include <mutex>

#include "_Define.h"
#include "core/ComplexOperators.h"
#include "core/Endian.h"
#include "core/Enums.h"
#include "core/Error.h"
#include "core/FileSystem.h"
#include "core/StaticAsserts.h"
#include "core/String.h"
#include "core/TypeTraits.h"
#include "ASBreakLine.h"
#include "ASFault.h"
#include "ASGridInterpolatorBlock.h"
#include "ASIterators.h"
#include "ASMatrix.h"
#include "ASShape.h"
#include "ASSlice.h"
#include "ASPoint.h"
#include "interpolator/ASInterpolator.h"

namespace ais
{
    using PMatrix = AIS_EXPORT Matrix<PointXYZ>;
    enum class EdgeNodeValueMethod : int
    {
        FILL = 0,
        NEAREST,
    };

    enum class InitTargetMatrixMethod : int
    {
        LINEAR = 0,
        LOG,
    };

    class AIS_EXPORT GridInterpolator
    {
    public:
        GridInterpolator();
        ~GridInterpolator();

        GridInterpolator(const std::vector<ais::PointXYZ> &randomPoints,     // random sample points
                         const std::vector<ais::Point> &areaPoints,          // result grid area corners points
                         std::shared_ptr<ais::FMatrix> targetMatrix,         // output target matrix
                         const std::vector<ais::BreakLine> &breaklines = {}, // break lines
                         const std::vector<ais::Fault> &faults = {}          // faults
        );

        //============================================================================
        // Method Description:
        /// Set the random sample points
        ///
        /// @param points
        ///
        void set_random_points(const std::vector<ais::PointXYZ> &points);

        //============================================================================
        // Method Description:
        /// Set the area points which limit the grid
        ///
        /// @param points
        ///
        void set_area_points(const std::vector<ais::Point> &points);

        //============================================================================
        // Method Description:
        /// Set the grid matrix by corner points and step, for output target
        ///
        /// @param areaPoints
        ///
        void set_result_matrix(ais::Matrix<double> &result, std::vector<ais::Point> &areaPoints);

		std::shared_ptr<ais::Matrix<double>> matrix();

        //============================================================================
        // Method Description:
        /// get the interpolation params
        ///
        /// @return params
        ///
        std::map<std::string, std::any> params();

        //============================================================================
        // Method Description:
        /// dump grid interpolation params to string
        std::string params_info();

        //============================================================================
        // Method Description:
        /// dump origin data statistics to string
        std::string dump_data_statistics();

        //============================================================================
        // Method Description:
        /// update grid interpolation params
        void update_grid_params(const std::map<std::string, std::any> &params);

        //============================================================================
        // Method Description:
        /// update grid interpolation for special area
        ///
        /// void update(std::vector<ais::PointXYZ> &changedArea);

        //============================================================================
        // Method Description:
        /// start grid interpolation
        ///
        /// @param interpolator, select specific interpolator to complete the interpolation
        ///
        void start(InterpolationMethod method = InterpolationMethod::MINIMUM_CURVATURE);

        //============================================================================
        // Method Description:
        /// abort grid interpolation
        ///
        inline void abort() { flagRunning_ = false; };

        //============================================================================
        // Method Description:
        /// Get total progress of grid interpolation
        ///
        std::string get_progress_msg();

        //============================================================================
        // Method Description:
        /// output statistics report for original data
        ///
        std::string report();

        //============================================================================
        // Method Description:
        /// dump points data to string
        std::string points_info();

        //============================================================================
        // Method Description:
        /// dump grid header info to string
        std::string header_info(std::shared_ptr<ais::FMatrix> dataMatrixPtr = {});

        //============================================================================
        // Method Description:
        /// dump grid data info to string
        std::string data_info(std::shared_ptr<ais::FMatrix> dataMatrixPtr = {});

        //============================================================================
        // Method Description:
        /// dump total iteration time info to string
        std::string iteration_time();

        //============================================================================
        // Method Description:
        /// dump result to file
        void dump_result(const char *filename, std::shared_ptr<ais::FMatrix> dataMatrixPtr = {});
        void dump_result_async(const std::string &filename, std::shared_ptr<ais::FMatrix> dataMatrixPtr = {}, int8_t detailLevel = 0);

        inline bool is_end() { return flagEnd_; }

        inline bool is_succeeded() { return flagSucceed_; }

    private:
        // params from constructor or set functions
        std::vector<ais::PointXYZ> randomPoints_;
        std::vector<ais::PointXYZ> randomPointPositions_;
        std::map<size_t, ais::PointXYZ> randomPointPositionsHash_;

        std::vector<ais::Point> areaPoints_; // points list to limit the interpolate area

        std::shared_ptr<ais::FMatrix> targetMatrixPtr_; // matrix = col points * row points

        // matrix which used to estimate surface, which dx/dy size is too smell to get smooth result
        std::shared_ptr<ais::FMatrix> estimateMatrixPtr_;
        size_t estimateFactor_ = 0;

        // corner smooth weight, which used to get smooth result on corner while there is no simple data
        // weight should between 4~256, default is 64
        size_t cornerWeight_ = 64;

        // breaklines & faults
        std::vector<ais::BreakLine> breaklines_;
        std::vector<ais::Fault> faults_;

        // grid attributes
        // constrain matrix，same shape and size as target matrix
        std::shared_ptr<ais::PMatrix> constrainMatrixPtr_;

        // matrix which storage the points in fault, used to add fault line on output matrix
        std::shared_ptr<ais::FMatrix> pointInFaultMatrixPtr_;
        // matrix which storage the fault affect block values, used to iteration the points value
        std::shared_ptr<ais::FMatrix> faultAffectMatrixPtr_;

        bool flagRunning_{false};
        bool flagMultiThread_{true};
        uint64_t iteration_{0}; // current iteration count

        double relaxationFactor_{1};   // relaxation factor, default 1 (0 Slowest~2 Fast)
        uint64_t maxIteration_{2000};  // max iteration, suggest 1~2 * total grids, default 2000
        double residual_{0.0001};      // residual, default 0.0001
        double epsMax_{std::nan("1")}; // epsMax = residual_ * (zMax - zMin)
        double fillValue_{0};          // fill value, default 0

        std::vector<double> x_;
        std::vector<double> y_;

        std::pair<double, double> xMinMax_, yMinMax_; // grid coordinates
        std::pair<double, double> zMinMax_;
        double zMean_;
        double dxSize_, dySize_; // grid spacing size
        double alpha_;           // alpha = dxSize_ / dySize_
        double beta_;            // beta = dySize_ / dxSize_

        size_t faultNodesCount_{0};

        std::atomic<bool> flagSucceed_{false}; // reach the max iterator or iteration output eps < maxResidual
        std::atomic<bool> flagEnd_{false};

        std::chrono::system_clock::time_point startTime_;
        std::chrono::system_clock::time_point endTime_;

        std::mutex dataMutex_;

        std::mutex msgMutex_;
        std::vector<std::string> interpolationMsgs_;

        std::mutex mapMutex_;
        std::map<size_t, ais::GridInterpolatorBlock<>> faultEdgePointExpandBoxes_;

        // output option
        int8_t faultEdgeLevel_{-1};
        int8_t detailLevel_{ 0 };

        // origin random points statistics
        std::map<std::string, double> dataStatistics_;

        //============================================================================
        // Method Description:
        /// generate suggestions for grid interpolation params
        void generate_grid_params(std::shared_ptr<ais::FMatrix> targetMatrixPtr);

        //============================================================================
        // Method Description:
        /// generate origin data statistics
        void generate_data_statistics();

        //============================================================================
        // Method Description:
        /// setup constraint point
        void setup_constraint_point(std::shared_ptr<ais::PMatrix> &cmp, size_t xi, size_t yi, double xGap, double yGap, const ais::PointXYZ &point);

        //============================================================================
        // Method Description:
        /// generate constraint points for breakline
        std::vector<PointXYZ> generate_constraint_points(const ais::BreakLine &breakline);

        //============================================================================
        // Method Description:
        /// generate constraint points for fault
        std::vector<PointXYZ> generate_constraint_points(const ais::Fault &fault);

        //============================================================================
        // Method Description:
        /// get nearest sample points for specified point
        std::vector<PointXYZ> get_nearest_samples(size_t x, size_t y, size_t min_count = 3, size_t max_count = 6);

        //============================================================================
        // Method Description:
        /// get range sample points for specified point, while radius == 0 or > max(x)
        std::vector<PointXYZ> get_range_samples(size_t xIndex, size_t yIndex, double xGridSize, double yGridSize, const std::vector<PointXYZ> &randoms, double radius = 0);

        //============================================================================
        // Method Description:
        /// convert sample points position to coordinates, simple calculating
        std::vector<PointXYZ> coordinates_points(const std::vector<PointXYZ> &points);

        //============================================================================
        // Method Description:
        /// get point hash map
        std::map<size_t, PointXYZ> points_hash_map(const std::vector<PointXYZ> &points);

        //============================================================================
        // Method Description:
        /// build the constraint matrix by input parameters
        ///
        void build_constraint_matrix(std::shared_ptr<ais::FMatrix> targetMatrixPtr, std::shared_ptr<ais::PMatrix> &constrainMatrixPtr);

        //============================================================================
        // Method Description:
        /// build the fault impact points matrix by input parameters
        ///
        /// @param in targetMatrixPtr: source matrix which used to build fault matrix
        /// @param in/out pointInFaultMatrixPtr: storage the point information which in matrix
        /// @param in/out faultAffectMatrixPtr: storage the fault affect matrix
        void build_fault_impact_matrix(std::shared_ptr<ais::FMatrix> targetMatrixPtr,
                                       std::shared_ptr<ais::FMatrix> &pointInFaultMatrixPtr,
                                       std::shared_ptr<ais::FMatrix> &faultAffectMatrixPtr);

        //============================================================================
        // Method Description:
        /// update edge node
        ///
        void update_edge_node(std::shared_ptr<ais::FMatrix> &targetMatrixPtr, EdgeNodeValueMethod method = EdgeNodeValueMethod::FILL);

        //============================================================================
        // Method Description:
        /// update nan node with fill value
        ///
        void update_nan_node(std::shared_ptr<ais::FMatrix> &targetMatrixPtr);

        //============================================================================
        // Method Description:
        /// detect estimate factor by input params
        ///
        size_t detect_estimate_factor();

        //============================================================================
        // Method Description:
        /// estimate matrix node if the estimate > 1
        ///
        void scale_estimate();

        //============================================================================
        // Method Description:
        /// estimate target matrix node with special method
        ///
        void estimate_gradients_surface(std::shared_ptr<ais::FMatrix> &targetMatrixPtr);
        void estimate_gradients_surface_2(InitTargetMatrixMethod method = InitTargetMatrixMethod::LINEAR);

        //============================================================================
        // Method Description:
        /// start interpolation in detached thread
        ///
        void start_interpolation(std::shared_ptr<ais::FMatrix> &targetMatrixPtr, std::shared_ptr<ais::PMatrix> &constrictMatrixPtr,
                                 std::shared_ptr<ais::FMatrix> &pointInFaultMatrixPtr, std::shared_ptr<ais::FMatrix> &faultAffectMatrixPtr,
                                 InterpolationMethod method = InterpolationMethod::MINIMUM_CURVATURE);

        //============================================================================
        // Method Description:
        /// minimum curvature interpolation main function
        ///
        bool update_min_curv_interpolation(std::shared_ptr<ais::FMatrix> &targetMatrixPtr, std::shared_ptr<ais::PMatrix> &constrictMatrixPtr,
                                           std::shared_ptr<ais::FMatrix> &pointInFaultMatrixPtr, std::shared_ptr<ais::FMatrix> &faultAffectMatrixPtr,
                                           const std::vector<ais::Point> &targetArea = {});

        //============================================================================
        // Method Description:
        /// update Minimum Curvature boundary
        ///
        /// @param update matrix for minimum curvature grid iteration
        /// @param column target matrix column
        /// @param row target matrix row
        /// @param alpha = dx/dy = x grid space size / y grid space size
        ///
        void update_min_curv_boundary(std::shared_ptr<ais::FMatrix> &ump, size_t column, size_t row, double alpha);

        //============================================================================
        // Method Description:
        /// interpolate the estimate matrix data to target matrix
        ///
        void interpolate_estimate_2_target();
    };
}