module VORuby
  module VOTables
    module VOTable
      class VOTable
        def self.from_soap_obj(mvot)
          VOTable.new(
            VOTable::_find_attr_value(mvot.__xmlattr, 'ID'),
            VOTable::_find_attr_value(mvot.__xmlattr, 'version'),
            (mvot.respond_to?(:dESCRIPTION))? Meta::Description.from_soap_obj(mvot.dESCRIPTION): nil,
            (mvot.respond_to?(:dEFINITIONS))? Meta::Definitions.from_soap_obj(mvot.dEFINITIONS): nil,
            (mvot.respond_to?(:cOOSYS))? Meta::CooSys.from_soap_obj(mvot.cOOSYS): [],
            (mvot.respond_to?(:pARAM))? Meta::Param.from_soap_obj(mvot.pARAM): [],
            (mvot.respond_to?(:iNFO))? Meta::Info.from_soap_obj(mvot.iNFO): [],
            (mvot.respond_to?(:rESOURCE))? Meta::Resource.from_soap_obj(mvot.rESOURCE): []
          )
        end
      end
  
      module Meta
    
        class Definitions
          def self.from_soap_obj(mdef)
            Definitions.new(
               (mdef.respond_to?(:cOOSYS))? VOTable._coosys_from_soap_obj(mdef.cOOSYS): nil,
               (mdef.respond_to?(:pARAM))? VOTable._params_from_soap_obj(mdef.pARAM): nil
             )
          end
        end
    
        class Description
          def self.from_soap_obj(mdesc)
            Description.new(mdesc)
          end
        end
    
        class CooSys
          def self.from_soap_obj(mcoosystems)
            mcoosystems = [mcoosystems] if !mcoosystems.respond_to(:each)

             coosys = []
             mcoosystems.each do |mcoosys|
               equinox_txt = VOTable::_find_attr_value(mcoosys.__xmlattr, 'equinox')
               epoch_txt = VOTable::_find_attr_value(mcoosys.__xmlattr, 'epoch')
               system_txt = VOTable::_find_attr_value(mcoosys.__xmlattr, 'system') || 'eq_FK5'

               coosys.push(CooSys.new(
                 VOTable::_find_attr_value(mcoosys.__xmlattr, 'ID'),
                 (equinox_txt == nil)? nil: Type::AstroYear.new(equinox_txt),
                 (epoch_txt == nil)? nil: Type::AstroYear.new(epoch_txt),
                 Type::CoordSystemType.new(system_txt)
               ))
             end

             coosys
          end
        end
    
        class Param
          def self.from_soap_obj(mparams)
            mparams = [mparams] if !mparams.respond_to?(:each)

            params = []
            mparams.each do |mparam|
              datatype_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'datatype')
              ucd_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'ucd')
              precision_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'precision')
              width_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'width')
              arraysize_txt = VOTable::_find_attr_value(mparam.__xmlattr, 'arraysize')

              params.push(Param.new(
                VOTable::_find_attr_value(mparam.__xmlattr, 'name'),
                (datatype_txt == nil)? nil: Type::DataType.new(datatype_txt),
                VOTable::_find_attr_value(mparam.__xmlattr, 'value'),
                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
                VOTable::_find_attr_value(mparam.__xmlattr, 'unit'),
                (mparam.respond_to?(:dESCRIPTION))? _description_from_soap_obj(mparam.dESCRIPTION): nil,
                (mparam.respond_to?(:vALUES))? _values_from_soap_obj(mparam.vALUES): nil,
                (mparam.respond_to?(:lINK))? _links_from_soap_obj(mapram.lINK): nil,
                VOTable::_find_attr_value(mparam.__xmlattr, 'ID'),
                (precision_txt == nil)? nil: Type::PrecisionType.new(precision_txt.to_i),
                VOTable::_find_attr_value(mparam.__xmlattr, 'utype'),
                (width_txt == nil)? nil: Type::PositiveInteger.new(width_txt.to_i),
                VOTable::_find_attr_value(mparam.__xmlattr, 'ref'),
                (arraysize_txt == nil)? nil: Type::ArrayDef.new(arraysize_txt)
              ))
            end
        
            params
          end
        end
    
        class Info
          def self.from_soap_obj(minfo)
            info = []
            info.push(Info.new(
              VOTable::_find_attr_value(minfo.__xmlattr, 'name'),
              VOTable::_find_attr_value(minfo.__xmlattr, 'value'),
              VOTable::_find_attr_value(minfo.__xmlattr, 'ID'),
              minfo.__xmlele # text
            ))
        
            info
          end
        end
    
        class Resource
          def self.from_soap_obj(mresources)
            mresources = [mresources] if !mresources.respond_to?(:each)

            resources = []
            mresources.each do |mres|
              type_txt = VOTable::_find_attr_value(mres.__xmlattr, 'type') || 'results'

              resources.push(Resource.new(
                VOTable::_find_attr_value(mres.__xmlattr, 'name'),
                VOTable::_find_attr_value(mres.__xmlattr, 'ID'),
                VOTable::_find_attr_value(mres.__xmlattr, 'utype'),
                Type::ResourceType.new(type_txt),
                (mres.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mres.dESCRIPTION): nil,
                (mres.respond_to?(:iNFO))? Info.from_soap_obj(mres.iNFO): [],
                (mres.respond_to?(:cOOSYS))? CooSys.from_soap_obj(mres.cOOSYS): [],
                (mres.respond_to?(:pARAM))? Param.from_soap_obj(mres.pARAM): [],
                (mres.respond_to?(:lINK))? Link.from_soap_obj(mres.lINK): [],
                Table.from_soap_obj(mres.tABLE),
                (mres.respond_to?(:rESOURCE))? Resource.from_soap_obj(mres.rESOURCE): []
              ))
            end

            resources
          end
        end
    
        class Table
          def self.from_soap_obj(mtables)
            mtables = [mtables] if !mtables.respond_to?(:each)

            tables = []
            mtables.each do |mtable|
              ucd_txt = VOTable::_find_attr_value(mtable.__xmlattr, 'ucd')
              nrows_txt = VOTable::_find_attr_value(mtable.__xmlattr, 'nrows')

              tables.push(Table.new(
                VOTable::_find_attr_value(mtable.__xmlattr, 'name'),
                VOTable::_find_attr_value(mtable.__xmlattr, 'ID'),
                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
                VOTable::_find_attr_value(mtable.__xmlattr, 'utype'),
                VOTable::_find_attr_value(mtable.__xmlattr, 'ref'),
                (nrows_txt == nil)? nil: Type::NonNegativeInteger.new(nrows_txt.to_i),
                (mtable.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mtable.dESCRIPTION): nil,
                (mtable.respond_to?(:fIELD))? Field.from_soap_obj(mtable.fIELD): [],
                (mtable.respond_to?(:pARAM))? Param.from_soap_obj(mtable.pARAM): [],
                (mtable.respond_to?(:gROUP))? Group.from_soap_obj(mtable.gROUP): [],
                (mtable.respond_to?(:lINK))? Link.from_soap_obj(mtable.lINK): [],
                (mtable.respond_to?(:dATA))? Data::Data.from_soap_obj(mtable.dATA): nil
              ))
            end

            tables
          end
        end
    
        class Group
          def self.from_soap_obj(mgroups)
            mgroups = [mgroups] if !mgroups.respond_to?(:each)

            groups = []
            mgroups.each do |mgroup|
              ucd_txt = OTable::VOTable::_find_attr_value(mgroup.__xmlattr, 'ucd')

              groups.push(Group.new(
                VOTable::_find_attr_value(mgroup.__xmlattr, 'name'),
                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
                (mgroup.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mgroup.dESCRIPTION): nil,
                (mgroup.respond_to?(:fIELDref))? FieldRef.from_soap_obj(mgroup.fIELDref): [],
                (mgroup.respond_to?(:pARAMref))? ParamRef.from_soap_obj(mgroup.pARAMref): [],
                (mgroup.respond_to?(:pARAM))? Param.from_soap_obj(mgroup.pARAM): [],
                (mgroup.respond_to?(:gROUP))? Group.from_soap_obj(mgroup.gROUP): [],
                VOTable::_find_attr_value(mgroup.__xmlattr, 'ID'),
                VOTable::_find_attr_value(mgroup.__xmlattr, 'ref'),
                VOTable::_find_attr_value(mgroup.__xmlattr, 'utype')
              ))
            end

            groups       
          end
        end
    
        class FieldRef
          def self.from_soap_obj(mfieldrefs)
            mfieldrefs = [mfieldrefs] if !mfieldrefs.respond_to?(:each)

            fieldrefs = []
            mfieldrefs.each do |mfieldref|
              fieldrefs.push(FieldRef.new(
                VOTable::_find_attr_value(mfieldref.__xmlattr, 'ref')
              ))
            end

            fieldrefs       
          end
        end
    
        class ParamRef
          def self.from_soap_obj(mparamrefs)
            mparamrefs = [mparamrefs] if !mparamrefs.respond_to?(:each)

            paramrefs = []
            mparamrefs.each do |mparamref|
              paramrefs.push(ParamRef.new(
                VOTABLE::VOTable::_find_attr_value(mparamref.__xmlattr, 'ref')
              ))
            end

            paramrefs        
          end
        end
    
        class Field
          def self.from_soap_obj(mfields)
            mfields = [mfields] if !mfields.respond_to?(:each)

            fields = []
            mfields.each do |mfield|
              datatype_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'datatype')
              ucd_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'ucd')
              precision_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'precision')
              width_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'width')
              arraysize_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'arraysize')
              type_txt = VOTable::_find_attr_value(mfield.__xmlattr, 'type')

              fields.push(Field.new(
                VOTable::_find_attr_value(mfield.__xmlattr, 'name'),
                (datatype_txt == nil)? nil: Type::DataType.new(datatype_txt),
                (ucd_txt == nil)? nil: Type::UCDType.new(ucd_txt),
                VOTable::_find_attr_value(mfield.__xmlattr, 'unit'),
                (mfield.respond_to?(:dESCRIPTION))? Description.from_soap_obj(mfield.dESCRIPTION): nil,
                (mfield.respond_to?(:vALUES))? Values.from_soap_obj(mfield.vALUES): nil,
                (mfield.respond_to?(:lINK))? Link.from_soap_obj(mfield.lINK): [],
                VOTable::_find_attr_value(mfield.__xmlattr, 'ID'),
                (precision_txt == nil)? nil: Type::PrecisionType.new(precision_txt),
                VOTable::_find_attr_value(mfield.__xmlattr, 'utype'),
                (width_txt == nil)? nil: Type::PositiveInteger.new(width_txt.to_i),
                VOTable::_find_attr_value(mfield.__xmlattr, 'ref'),
                (arraysize_txt == nil)? nil: Type::ArrayDef.new(arraysize_txt),
                (type_txt == nil)? nil: Type::FieldType.new(type_txt)
              ))
            end
        
            fields
          end
        end
    
        class Link
          def self.from_soap_obj(mlinks)
            mlinks = [mlinks] if !mlinks.respond_to?(:each)

             links = []
             mlinks.each do |mlink|
               href_txt = VOTable::_find_attr_value(mlink.__xmlattr, 'href')
               action_txt = VOTable::_find_attr_value(mlink.__xmlattr, 'action')
               content_role_txt = VOTable::_find_attr_value(mlink.__xmlattr, 'content-role')

               links.push(Link.new(
                 (href_txt == nil)? nil: VOTABLE::Type::AnyURI.new(href_txt),
                 VOTable::_find_attr_value(mlink.__xmlattr, 'value'),
                 VOTable::_find_attr_value(mlink.__xmlattr, 'title'),
                 (action_txt == nil)? nil: VOTABLE::Type::AnyURI.new(action_txt),
                 VOTable::_find_attr_value(mlink.__xmlattr, 'ID'),
                 VOTable::_find_attr_value(mlink.__xmlattr, 'content-type'),
                 (content_role_txt == nil)? nil: Type::ContentRole.new(content_role_txt),
                 VOTable::_find_attr_value(mlink.__xmlattr, 'ghref')
               ))
             end

             links       
          end
        end
    
        class Values
          def self.from_soap_obj(mvalues)
            type_txt = VOTable::_find_attr_value(mvalues.__xmlattr, 'type') || 'legal'

            Values.new(
               (mvalues.respond_to?(:mIN))? Min.from_soap_obj(mvalues.mIN): nil,
               (mvalues.respond_to?(:mAX))? Max.from_soap_obj(mvalues.mAX): nil,
               (mvalues.respond_to?(:oPTIONS))? Option.from_soap_obj(mvalues.oPTIONS): [],
               VOTable::_find_attr_value(mvalues.__xmlattr, 'ID'),
               (type_txt == nil)? nil: Type::ValuesType.new(type_txt),
               VOTable::_find_attr_value(mvalues.__xmlattr, 'null'),
               VOTable::_find_attr_value(mvalues.__xmlattr, 'ref')
             )       
          end
        end
    
        class Option
          def self.from_soap_obj(moptions)
            options = []
            moptions.each do |moption|
              options.push(Option.new(
                VOTable::_find_attr_value(mvalues.__xmlattr, 'value'),
                VOTable::_find_attr_value(mvalues.__xmlattr, 'name'),
                (moption.respond_to?(:oPTION))? Option.from_soap_obj(moption.oPTION): []
            ))
            end
        
            options
          end
        end
    
        class Min
          def self.from_soap_obj(mmin)
            inclusive_txt = VOTable::_find_attr_value(mmin.__xmlattr, 'inclusive') || 'yes'

            Min.new(
              VOTable::_find_attr_value(mmin.__xmlattr, 'value'),
              Type::YesNo.new(inclusive_txt)
            )       
          end
        end
    
        class Max
          def self.from_soap_obj(mmax)
            inclusive_txt = VOTable::_find_attr_value(mmax.__xmlattr, 'inclusive') || 'yes'

            Max.new(
              VOTable::_find_attr_value(mmax.__xmlattr, 'value'),
              Type::YesNo.new(inclusive_txt)
            )        
          end
        end
    
      end
  
      module Data
  
        class Data
          def self.from_soap_obj(mdata)
            # Note that strictly one can also have a FITS or BINARY stream here
            Data.new(
              (mdata.respond_to?(:tABLEDATA))? TableData.from_soap_obj(mdata.tABLEDATA): nil
            )
          end
        end
  
        class TableData
          def self.from_soap_obj(mtbldata)
            TableData.new(
               (mtbldata.respond_to?(:tR))? TR.from_soap_obj(mtbldata.tR): []
             )        
          end
        end
    
        class TR
          def self.from_soap_obj(mtrs)
            mtrs = [mtrs] if !mtrs.respond_to?(:each)

            trs = []
            mtrs.each do |tr|
              trs.push(
                (tr.respond_to?(:tD))? TR.new(TD.from_soap_obj(tr.tD)): []
              )
            end

            trs
          end
        end
    
        class TD
          def self.from_soap_obj(mtds)
            mtds = [mtds] if !mtds.respond_to?(:each)

            tds = []
            mtds.each do |td|
              tds.push(TD.new(
                td,
                (td.respond_to?(:__xmlattr))? VOTable::_find_attr_value(td.__xmlattr, 'encoding'): Type::EncodingType.new('none')
              ))
            end

            tds
          end
        end
    
      end
    end
    
  end
end