#pragma once
#include "FluidSim/AudioProcessing.hpp"
#include <algorithm>
#include <cmath>
#include <stdexcept>
#include <vector>
#include <utility>
namespace fluidsim::port::desktop {
struct PipeAnchor {float distance;Vec3 position;};
// Piecewise straight centerline; knot distances are measured from its geometry.
class PipePath {
public:
    explicit PipePath(std::vector<PipeAnchor> anchors):anchors_(std::move(anchors)) {
        if(anchors_.size()<2 || anchors_.front().distance!=0)throw std::invalid_argument("pipe path needs origin and endpoint");
        for(std::size_t i=0;i<anchors_.size();++i) {
            const auto& p=anchors_[i];
            if(!std::isfinite(p.distance) || !std::isfinite(p.position.x) || !std::isfinite(p.position.y) || !std::isfinite(p.position.z) ||
               (i && !(p.distance>anchors_[i-1].distance))) throw std::invalid_argument("invalid distance-referenced pipe path");
        }
    }
    Vec3 position(float distance) const {
        distance=std::clamp(distance,0.f,anchors_.back().distance);
        auto it=std::upper_bound(anchors_.begin(),anchors_.end(),distance,[](float s,const PipeAnchor& a){return s<a.distance;});
        std::size_t i=std::clamp<std::size_t>(it-anchors_.begin(),1,anchors_.size()-1)-1;
        const auto& a=anchors_[i];const auto& b=anchors_[i+1];
        const float t=(distance-a.distance)/(b.distance-a.distance);
        return {std::lerp(a.position.x,b.position.x,t),std::lerp(a.position.y,b.position.y,t),std::lerp(a.position.z,b.position.z,t)};
    }
    Vec3 tangent(float distance) const {
        const float epsilon=anchors_.back().distance*.0001f;
        const auto a=position(distance-epsilon),b=position(distance+epsilon);
        const float x=b.x-a.x,y=b.y-a.y,z=b.z-a.z,n=std::sqrt(x*x+y*y+z*z);
        return n>1e-8f?Vec3{x/n,y/n,z/n}:Vec3{1,0,0};
    }
    Vec3 miter_offset(float distance,Vec3 radial) const {
        const auto unit=[](Vec3 v){const float n=std::sqrt(v.x*v.x+v.y*v.y+v.z*v.z);return Vec3{v.x/n,v.y/n,v.z/n};};
        for(std::size_t i=1;i+1<anchors_.size();++i)if(std::abs(distance-anchors_[i].distance)<1e-6f) {
            const auto a=anchors_[i-1].position,b=anchors_[i].position,c=anchors_[i+1].position;
            const auto u=unit({b.x-a.x,b.y-a.y,b.z-a.z}),v=unit({c.x-b.x,c.y-b.y,c.z-b.z});
            const float cosine=std::clamp(u.x*v.x+u.y*v.y+u.z*v.z,-1.f,1.f);
            if(cosine>.99999f)return radial;
            const auto bend=unit({u.x-v.x,u.y-v.y,u.z-v.z});
            const float scale=std::min(3.f,1/std::sqrt(std::max(.0001f,(1+cosine)*.5f)));
            const float extension=(radial.x*bend.x+radial.y*bend.y+radial.z*bend.z)*(scale-1);
            return {radial.x+bend.x*extension,radial.y+bend.y*extension,radial.z+bend.z*extension};
        }
        return radial;
    }
private:
    std::vector<PipeAnchor> anchors_;
};
}