コーディング規約：CERT C++ ルールと推奨事項を厳守したバイブコーディングの紹介

// ファイル名: vibe_safety_engine.cpp
// 目的: 最高に安全でありながら「それなりに気持ちいい」振動パターン生成
// CERT C++ 準拠度: ほぼ全力（メモリ安全・算術安全・スレッド安全）

#include <cstdint>
#include <limits>
#include <array>
#include <chrono>
#include <random>
#include <algorithm>
#include <atomic>
#include <mutex>

namespace safe_vibe
{
    using pwm_value_t   = std::uint16_t;
    using duration_ms_t = std::uint32_t;

    namespace constants
    {
        constexpr pwm_value_t PWM_MIN         = 0;
        constexpr pwm_value_t PWM_MAX         = 1023;
        constexpr pwm_value_t PWM_SAFE_MAX    = 900;       // 過熱防止マージン
        constexpr duration_ms_t MIN_PULSE     = 8;         // 人間が感じにくい領域を避ける
        constexpr duration_ms_t MAX_PULSE     = 4000;
        constexpr std::size_t   HISTORY_DEPTH = 8;         // 直近履歴による急変防止
    }

    class VibePattern final
    {
    public:
        using value_type      = pwm_value_t;
        using size_type       = std::size_t;

        static constexpr size_type MAX_STEPS = 256;

    private:
        // [MEM51-CPP] 動的確保を避け、静的サイズ配列を使用
        std::array<value_type,    MAX_STEPS> amplitudes{};
        std::array<duration_ms_t, MAX_STEPS> durations{};
        size_type length{0};

        // 直近の出力履歴（急激な変化防止用）
        mutable std::array<value_type, constants::HISTORY_DEPTH> history{};
        mutable size_type history_pos{0};

        [[nodiscard]] static constexpr bool is_valid_amplitude(value_type v) noexcept
        {
            return v >= constants::PWM_MIN && v <= constants::PWM_SAFE_MAX;
        }

        [[nodiscard]] static constexpr bool is_valid_duration(duration_ms_t ms) noexcept
        {
            return ms >= constants::MIN_PULSE && ms <= constants::MAX_PULSE;
        }

        // [INT30-C] 整数オーバーフロー・アンダーフローを完全に防御
        [[nodiscard]] value_type limit_rate_of_change(value_type target) const noexcept
        {
            if (length == 0) return target;

            value_type prev = history[history_pos];
            constexpr pwm_value_t MAX_DELTA_PER_STEP = 180;

            if (target > prev)
            {
                return (target - prev > MAX_DELTA_PER_STEP) ? prev + MAX_DELTA_PER_STEP : target;
            }
            else
            {
                return (prev - target > MAX_DELTA_PER_STEP) ? prev - MAX_DELTA_PER_STEP : target;
            }
        }

    public:
        VibePattern() noexcept = default;

        // [MSC54-CPP] [MSC63-CPP] 意図しないコピーによるリソース競合を防止
        VibePattern(const VibePattern&)            = delete;
        VibePattern& operator=(const VibePattern&) = delete;

        VibePattern(VibePattern&&) noexcept            = default;
        VibePattern& operator=(VibePattern&&) noexcept = default;

        ~VibePattern() = default;

        [[nodiscard]] bool add_step(value_type amp, duration_ms_t ms) noexcept
        {
            if (length >= MAX_STEPS)                    return false;
            if (!is_valid_amplitude(amp))               return false;
            if (!is_valid_duration(ms))                 return false;

            amplitudes[length] = amp;
            durations[length]  = ms;
            ++length;

            return true;
        }

        [[nodiscard]] value_type get_next_amplitude() const noexcept
        {
            if (length == 0) return constants::PWM_MIN;

            value_type target = amplitudes[0];
            target = limit_rate_of_change(target);

            // 履歴更新（環状バッファ）
            history[history_pos] = target;
            history_pos = (history_pos + 1) % constants::HISTORY_DEPTH;

            return target;
        }

        [[nodiscard]] duration_ms_t get_next_duration() const noexcept
        {
            return length ? durations[0] : 100;
        }

        void advance() noexcept
        {
            if (length == 0) return;

            // ローテーション（メモリアクセスを最小限に）
            std::rotate(amplitudes.begin(), amplitudes.begin() + 1, amplitudes.begin() + length);
            std::rotate(durations.begin(),  durations.begin()  + 1, durations.begin()  + length);

            // 防御的プログラミング：使用済み要素の無効化
            amplitudes[length-1] = constants::PWM_MIN;
        }
    };

    class SafeVibeGenerator
    {
    private:
        // [MSC51-CPP] 非決定的な乱数生成
        std::minstd_rand engine{std::random_device{}()};
        VibePattern current_pattern;
        std::mutex pattern_mtx;
        std::atomic<bool> running{false};

    public:
        void start_random_pattern() noexcept
        {
            bool expected = false;
            if (!running.compare_exchange_strong(expected, true, std::memory_order_acq_rel))
            {
                return; 
            }

            std::lock_guard lk{pattern_mtx};
            current_pattern = VibePattern{};

            // 安全なプリセットベースの揺らぎ生成
            constexpr std::array<std::pair<pwm_value_t, duration_ms_t>, 5> base_patterns = {{
                {320, 120}, {580, 85}, {720, 140}, {450, 200}, {280, 320}
            }};

            std::uniform_int_distribution<std::size_t> dist(0, base_patterns.size()-1);

            for (int i = 0; i < 12; ++i)
            {
                auto [base_amp, base_dur] = base_patterns[dist(engine)];
                
                // [INT30-C] 範囲外にならないようclampで保護
                pwm_value_t amp = std::clamp<pwm_value_t>(base_amp, constants::PWM_MIN, constants::PWM_SAFE_MAX);
                duration_ms_t dur = std::clamp<duration_ms_t>(base_dur, constants::MIN_PULSE, constants::MAX_PULSE);

                current_pattern.add_step(amp, dur);
            }
        }

        void tick() noexcept
        {
            std::lock_guard lk{pattern_mtx};
            current_pattern.advance();
        }

        void stop() noexcept
        {
            running.store(false, std::memory_order_release);
        }
    };
} // namespace safe_vibe