module run_xml
    
    use model_xml
    use assign_values
    use run_def, MODEL => Run    
    implicit none

    !by default hide everything
    private

    !only expose the required procedures
    public :: parseRunNode

    character (len = *), parameter :: tag_barriers = "barriers"
    character (len = *), parameter :: tag_barrier = "barrier"
    


contains
    !the generic model xml logic, MODEL is mapped to run
    include "util/xml/model_xml.inc"


    !public entry point for a run node
    function parseRunNode(np, parentformat, parentmeta) result(mp)
        type(MODEL), pointer :: mp
        type(Node), pointer, intent(in) :: np        
        real, optional, intent(in) :: parentformat, parentmeta
        
        !version variables        
        real :: format =0, meta = 0

        !create a new model object 
        mp => run_new()
                
        !call the root model parsing
        call parseModel(mp=mp, &
                        np=np, &
                        parentformat= parentformat, &
                        format=format, &
                        parentmeta=parentmeta, &
                        meta=meta, &
                        name=mp%name, &
                        meta_verify=verifyMetaVersion )

        !parse the run layers
        call parseModelChildren(mp, np, format, meta, &
        tag_barriers, tag_barrier, child_callback = barrier_callback) 

    end function
    
    subroutine verifyMetaVersion(meta)        
        real, intent(in) :: meta
        !verify the run meta version
        if (.not.checkRange(meta, minin = 2.0)) then
            print *, "ERROR: Invalid run meta version.", meta
            call exit(1)
        end if
    end subroutine

    !callback for each layer element in layers
    subroutine barrier_callback(mp, cnp, format, meta, child_index, child_count)
        use barrier_def
!        use barrier_xml
        
        type(MODEL), pointer, intent(in) :: mp
        type(Node), pointer, intent(in) :: cnp
        real, intent(in) :: format, meta
        integer, intent(in) :: child_index, child_count
                                
        type(Barrier), pointer :: bar
                    
        !parse the layer
!        layer => parseMockLayerNode(np=cnp, parentformat=format, parentmeta=meta)
        
        !add the layer to the mock
!        call mock_addlayer(mp, layer)                   
        
    end subroutine

    !the uber important heavy lifting!
    subroutine assignParameterValue(mp, format, meta, pnp, vnp, name, value, units, &
        series_index, series_count, index, count, dim_index, dim_count)
        
        use fox_m_fsys_parse_input, only: rts

        !model pointer
        type(MODEL), pointer, intent(in) :: mp
        !format version, meta version
        real, intent(in) :: format, meta
        !parameter node pointer, value node pointer
        type(Node), pointer, intent(in) :: pnp, vnp
        !parameter name, value, units
        character(len = *), intent(in) :: name, value, units
        !indexed location of the value
        integer, intent(in) :: series_index, series_count, index, count, dim_index, dim_count
                
        !nothing fancy with series or dimensions
!        call verifyModelParameterCount(series_count=series_count, max_series_count=0, &
!            value_count=value_count, max_value_count=1, dim_count=dim_count, max_dim_count=1)
  
        select case (name)
            !first we'll skip all the tags ignored by the science code
!            case ("p_string")
!                call assign(value, mp%p_string)                 
!            case ("p_boolean")
!                call assign(value, mp%p_boolean)
!            case ("p_real")
!                call assign(value, mp%p_real)                 
!            case ("p_integer")
!                call assign(value, mp%p_integer)
            case default
                print *, "WARNING: unknown run parameter: ", name                    
        end select 
        

    end subroutine
    


end module