MTKCompat

module MTKCompat
    using ..Variables: z
    using ModelingToolkit
    using ModelingToolkitStandardLibrary
    using ModelingToolkit: @component
    using ModelingToolkitStandardLibrary.Blocks: get_sampled_data, SampledDataType, Parameter, RealOutput

    """
    SampledDataZ(; name, buffer, sample_time, circular_buffer=true)

    data input component.

    # Parameters:
    - `buffer::Vector{Real}`:  holds the data sampled at `sample_time`
    - `sample_time::Real`
    - `circular_buffer::Bool = true`: how to handle `t > length(buffer)*sample_time`.  If true data is considered circular, otherwise last data point is held.

    # Connectors:
    - `output`
    """
    @component function SampledDataZ(::Val{SampledDataType.vector_based};
            name,
            buffer,
            sample_time,
            circular_buffer = true)
        T = eltype(buffer)
        pars = @parameters begin
            buffer::Vector{T} = buffer #::Vector{Real}
            sample_time::T = sample_time #::Real
            circular_buffer::Bool = circular_buffer #::Bool
        end
        @parameters p::Parameter{T} = Parameter(buffer, sample_time, circular_buffer)
        vars = []
        systems = @named begin
            output = RealOutput()
        end
        eqs = [
            output.u ~ get_sampled_data(z, p)
        ]
        return ODESystem(eqs, z, vars, [pars; p]; name, systems,
            defaults = [
                output.u => get_sampled_data(0.0, p)
            ])
    end

    """
        SampledDataZ(; name, buffer)

    data input component.

    # Parameters:
    - `buffer`: a `Parameter` type which holds the data and sample time

    # Connectors:
    - `output`
    """
    @component function SampledDataZ(
            ::Val{SampledDataType.struct_based}; name, buffer::Parameter)
        pars = @parameters begin
            buffer::typeof(buffer) = buffer #::Parameter
        end
        @show pars
        vars = []
        systems = @named begin
            output = RealOutput()
        end
        eqs = [
            output.u ~ get_sampled_data(z, buffer)
        ]
        return ODESystem(eqs, z, vars, pars; name, systems,
            defaults = [output.u => get_sampled_data(0.0, buffer)])
    end

    SampledDataZ(x::SampledDataType.Option; kwargs...) = SampledDataZ(Val(x); kwargs...)

    # struct_based
    function SampledDataZ(T::Type, circular_buffer = true; name)
        SampledDataZ(SampledDataType.struct_based;
            name,
            buffer = Parameter(T[], zero(T), circular_buffer))
    end

    # vector_based
    function SampledDataZ(sample_time::T, circular_buffer = true; name) where {T <: Real}
        SampledDataZ(SampledDataType.vector_based;
            name,
            buffer = T[],
            sample_time,
            circular_buffer)
    end
    function SampledDataZ(buffer::Vector{<:Real},
            sample_time::Real,
            circular_buffer = true;
            name)
        SampledDataZ(SampledDataType.vector_based; name, buffer, sample_time, circular_buffer)
    end
    function SampledDataZ(; name, buffer, sample_time, circular_buffer)
        SampledDataZ(SampledDataType.vector_based; name, buffer, sample_time, circular_buffer)
    end

    export SampledDataZ
end