! $Id$
module data_write_tools
   implicit none

   type cr_data_type
      character ( len = 3 ) :: key
      character ( len = 50 ) :: name
      character ( len = 100) :: longname
      logical :: is_scaled
      real :: offset
      double precision:: slope 
      integer :: nx
      integer :: ny
      integer :: nx_full
      integer :: ny_full
      real , dimension( :,: ), allocatable :: data
      integer , dimension(:,:), allocatable :: data_scaled
      character (len=256) :: filename = 'test2.h5'
      
      integer :: h5_offset (2)
      integer :: h5_count  (2) 
      
      logical :: h5_created = .false.
      
      
   
   contains
      procedure :: init
      procedure :: get_property
      procedure :: set_property
      procedure :: update
      procedure :: write_to_h5
   end type cr_data_type

contains
   subroutine init ( self  , nx_full , ny_full )
      class ( cr_data_type ) :: self
      integer , intent (in) :: nx_full , ny_full
      
      self % h5_offset = [0,0]
      self % nx_full = nx_full  
      self % ny_full = ny_full
   
   end subroutine init

   subroutine get_property ( self &
      , nx , ny , data )
      class ( cr_data_type ) :: self
      integer , intent(out) , optional :: nx
      integer , intent(out) , optional :: ny
      real , intent(out) , optional  :: data(:,:)
      
      if ( present ( nx ) ) nx = self % nx
      if ( present ( ny ) ) ny = self % ny
      if ( present ( data ) ) data = self % data
   end subroutine

  subroutine set_property ( self &
      , nx , ny , data ,file , name  )
      class ( cr_data_type ) :: self
      integer , intent(in) , optional :: nx
      integer , intent(in) , optional :: ny
      real , intent(in) , optional :: data(:,:)
      character ( len = *) , optional :: file
      character ( len = *) , optional :: name
      
      
      if ( present ( nx ) )  self % nx = nx
      if ( present ( ny ) )  self % ny = ny
      if ( present( file) ) self % filename = file
      if ( present( name ) ) self % name = name
      if ( present ( data ) )  then
         allocate ( self % data , source = data )
         self % data = data
          call self % update ()
      end if   
   end subroutine
   
   subroutine update ( self )
      class ( cr_data_type ) :: self   
      integer :: dim_data ( 2)
      dim_data = shape ( self % data)
      
      self % nx = dim_data (1)
      self % ny = dim_data (2)
   
   end subroutine update
   
   
   subroutine write_to_h5 ( self  )
      
      use hdf5
      
      implicit none
      class ( cr_data_type ) :: self
      integer :: hdferr
      INTEGER(HID_T) :: file_id       ! File identifier
      integer (HSIZE_T) :: dims(1:2),dims1(1:2),dims_full(1:2)
      integer ( HID_T) :: file_h5 , dataspace , dset, memspace,cparms,filespace
      integer( HSIZE_T) ::data_dims(7)
      integer (HSIZE_T) :: count(1:2), offset(1:2), stride(1:2), block(1:2), max_dims(1:2)
      integer :: rank = 2
      character (len = 9):: ppp
      
      call h5open_f(hdferr)
      CALL h5fopen_f (trim(self % filename), H5F_ACC_RDWR_F, file_id, hdferr)
      dims = [self%nx,self%ny]
      block =[1,1]
      stride=[1,1]
      
      data_dims(1) = dims1(1)
      data_dims(2) = dims1(2)
      
      
      print*, self % h5_created
      if ( self % h5_created ) then
         CALL h5dopen_f(file_id, self % name , dset, hdferr)
         CALL h5dget_space_f(dset, dataspace, hdferr)
         offset = self % h5_offset
         count = dims
        
         CALL h5sselect_hyperslab_f(dataspace, H5S_SELECT_SET_F, &
            offset, count , hdferr, stride, BLOCK) 
            
         CALL h5screate_simple_f(rank, dims, memspace, hdferr)  
        
         call h5dwrite_f (dset, H5T_NATIVE_REAL, self% data, data_dims, hdferr &
            & ,  memspace, dataspace) 
           
      else
         dims_full = [self % nx_full, self % ny_full]
         call h5screate_simple_f ( 2 , dims_full, dataspace ,hdferr )
         call h5dcreate_f(file_id,  self % name , H5T_NATIVE_REAL,dataspace,dset,hdferr)
         CALL h5screate_simple_f(rank, dims_full , memspace, hdferr)
         print*,'before write'
         call h5dwrite_f (dset, H5T_NATIVE_REAL, self% data, data_dims, hdferr )
         print*,'mmmk', self % name
        
      
      end if 
      
      CALL h5sclose_f(dataspace, hdferr)
      CALL h5dclose_f(dset, hdferr)
      
      CALL h5fclose_f(file_id, hdferr)
      self % h5_created = .true.
      self % h5_offset(2) = offset(2) + dims(2)
      
       
      
     
            
            
   end subroutine write_to_h5
   

end module data_write_tools


!program test_me
!   use data_write_tools
!   use cr_file_mdl
!   type ( cr_data_type ) :: dat
!   type ( cr_file_type ) :: file
!   integer :: u
!   real :: q(30,40)
!   character (len = 256) :: file_h5
   
!   q=44. 
   
!   file % full_file ='test.h5'
!   call file % create()
   
!   call dat % set_property ( nx = 4, ny=88  )
!   call dat % get_property ( nx = u  )
   
!   call dat % set_property ( data = q  )
!   call dat % get_property ( nx = u  )
   
!   print*, dat % ny
   
  
!   file_h5 = 'test2.h5'
!   file % full_file =file_h5
!   call file % create()
!   call dat % set_property ( file = trim(file_h5)   )
!   call dat % write_to_h5 
   
   
   


!end program test_me