!-------------------------------------------------------------------------------
! Get the probabilitz for nD Classifiers
!-------------------------------------------------------------------------------

module CALC_PROB_MASK_PHASE

 use NB_CLOUD_MASK_SERVICES

 implicit none

 public GET_PROB_MASK_PHASE

 contains

subroutine GET_PROB_MASK_PHASE (X,Y,Z,Satzen, Solzen, Lunzen, Solglintzen, Lunglintzen,&
                        Solscatang, Tpw, Tsfc, Zsfc, Land_Class , Snow_Class, Solglint_Mask, &
                        Coast_Mask, Isfc, Class_Idx, Lut, Missing_Value, &
                        Clear_Cond_Ratio, Water_Cond_Ratio, Ice_Cond_Ratio, Obs_Prob)

! Assumption is that x,y,z are all initialized by call routine.

    REAL, intent(in) :: X, Y, Z
    REAL, intent(in) :: Satzen, Solzen, Lunzen
    REAL, intent(in) :: Solglintzen, Lunglintzen
    REAL, intent(in) :: Solscatang, Missing_Value, Zsfc
    REAL, intent(in) :: Tpw, Tsfc, Solglint_Mask
    REAL, intent(in) :: Land_class, Snow_Class, Coast_Mask
    INTEGER, intent(in) :: Isfc, Class_Idx
    REAL, intent(out) :: Clear_Cond_Ratio, Water_Cond_Ratio, &
                                     Ice_Cond_Ratio, Obs_Prob
    type(Classifier), intent(in), dimension (:) :: Lut
    REAL :: Obs_Prob_Thresh
    INTEGER :: Ix, Iy, Iz
    INTEGER :: Classifier_Rank
    
    Classifier_Rank = Lut(Class_Idx)%Rank
    
    
    !initialize variables
    Clear_Cond_Ratio = Missing_Value
    Water_Cond_Ratio = Missing_Value
    Ice_Cond_Ratio = Missing_Value
    Obs_Prob = Missing_Value
    

    !-- check for data that is withing the limits for this classifier
    if (Lut(Class_Idx)%On_Flag(Isfc) == 0) RETURN

    if (Satzen /= Missing_Value .AND. &
       (Satzen < Lut(Class_Idx)%Zen_Min .OR. &
        Satzen > Lut(Class_Idx)%Zen_Max)) RETURN

    if (Solzen /= Missing_Value .AND. &
       (Solzen < Lut(Class_Idx)%Solzen_Min .OR. &
        Solzen > Lut(Class_Idx)%Solzen_Max)) RETURN

    if (Solglintzen /= Missing_Value .AND. &
        Land_Class >= 5 .AND. &
        Snow_Class == 1 .AND. &  
       (Solglintzen < Lut(Class_Idx)%Solglintzen_Min .OR. &
        Solglintzen > Lut(Class_Idx)%Solglintzen_Max)) RETURN

    if (Lunglintzen /= Missing_Value .AND. &
        Land_Class >= 5 .AND. &
        Snow_Class == 1 .AND. &  
       (Lunglintzen < Lut(Class_Idx)%Lunglintzen_Min .OR. &
        Lunglintzen > Lut(Class_Idx)%Lunglintzen_Max)) RETURN

    if (Solglint_Mask >= 0 .and. Land_Class >= 5 .and. Snow_Class == 1 .and. &
       (Solglint_Mask < Lut(Class_Idx)%Solglint_Mask_Min .OR. &
        Solglint_Mask > Lut(Class_Idx)%Solglint_Mask_Max)) RETURN

    if (Solscatang /= Missing_Value .AND. &
       (Solscatang < Lut(Class_Idx)%Solscatang_Min .OR. &
        Solscatang > Lut(Class_Idx)%Solscatang_Max)) RETURN

    if (Tpw /= Missing_Value .AND. &
       (Tpw < Lut(Class_Idx)%Tpw_Min .OR. &
        Tpw > Lut(Class_Idx)%Tpw_Max)) RETURN

    if (Tsfc /= Missing_Value .AND. &
       (Tsfc < Lut(Class_Idx)%Tsfc_Min .OR. &
        Tsfc > Lut(Class_Idx)%Tsfc_Max)) RETURN

    if (Zsfc < Lut(Class_Idx)%Zsfc_Min .OR. &
        Zsfc > Lut(Class_Idx)%Zsfc_Max) RETURN

    if (Snow_Class >= 1 .AND. &
       (Snow_Class < Lut(Class_Idx)%Snow_Class_Min .OR. &
        Snow_Class > Lut(Class_Idx)%Snow_Class_Max)) RETURN

    if (Coast_Mask >= 0 .AND. &
       (Coast_Mask < Lut(Class_Idx)%Coast_Mask_Min .OR. &
        Coast_Mask > Lut(Class_Idx)%Coast_Mask_Max)) RETURN

    !--- check for valid data
    if (X == Missing_Value) RETURN
    if (Isfc .le. 0) RETURN

    if (Classifier_Rank .ge. 2) then 
       if (Y == Missing_Value) RETURN
    endif

    if (Classifier_Rank .ge. 3) then 
       if (Z == Missing_Value) RETURN
    endif


     
    ! --- determine probabilitz

    Ix = min((Lut(Class_Idx)%Nbins_X), max(1,NINT((X - &
                                           Lut(Class_Idx)%X_Min) / &
                                           Lut(Class_Idx)%X_Bin)))
    Iy = 0
    Iz = 0

    if (Classifier_Rank >=  2) then 
       if (Y == Missing_Value) RETURN
       Iy = min((Lut(Class_Idx)%Nbins_Y), max(1,NINT((Y - &
                                           Lut(Class_Idx)%Y_Min) / &
                                           Lut(Class_Idx)%Y_Bin)))
    endif

    if (Classifier_Rank >= 3) then 
       if (Z == Missing_Value) RETURN
       Iz = min((Lut(Class_Idx)%Nbins_Z), max(1,NINT((Z - &
                                           Lut(Class_Idx)%Z_Min) / &
                                           Lut(Class_Idx)%Z_Bin)))
    endif
    
    Obs_Prob_thresh = 0.0
    
    SELECT CASE (Classifier_Rank)
        CASE (1)
            Obs_Prob = Lut(Class_Idx)%Obs_Table(Ix,Isfc,1,1)
            if (Obs_Prob > Obs_Prob_thresh) then
               Clear_Cond_Ratio = Lut(Class_Idx)%Clear_Table(Ix,Isfc,1,1)
               Ice_Cond_Ratio =   Lut(Class_Idx)%Ice_Table(Ix,Isfc,1,1)
               Water_Cond_Ratio = Lut(Class_Idx)%Water_Table(Ix,Isfc,1,1)
            endif
        CASE (2)
            Obs_Prob = Lut(Class_Idx)%Obs_Table(Ix,Iy,Isfc,1)
            if (Obs_Prob > Obs_Prob_thresh) then
               Clear_Cond_Ratio = Lut(Class_Idx)%Clear_Table(Ix,Iy,Isfc,1)
               Ice_Cond_Ratio =   Lut(Class_Idx)%Ice_Table(Ix,Iy,Isfc,1)
               Water_Cond_Ratio = Lut(Class_Idx)%Water_Table(Ix,Iy,Isfc,1)
            endif
        CASE (3)
            Obs_Prob = Lut(Class_Idx)%Obs_Table(Ix,Iy,Iz,Isfc)
            if (Obs_Prob > Obs_Prob_thresh) then
               Clear_Cond_Ratio = Lut(Class_Idx)%Clear_Table(Ix,Iy,Iz,Isfc)
               Ice_Cond_Ratio =   Lut(Class_Idx)%Ice_Table(Ix,Iy,Iz,Isfc)
               Water_Cond_Ratio = Lut(Class_Idx)%Water_Table(Ix,Iy,Iz,Isfc)
            endif
        CASE DEFAULT
            PRINT *, "INVALID CLASSIFIER RANK"
            RETURN
        END SELECT


RETURN

end subroutine GET_PROB_MASK_PHASE

end module CALC_PROB_MASK_PHASE