$:.unshift(File.dirname(__FILE__)) unless
	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))

$:.unshift(File.dirname(__FILE__+"\\..")) unless
	$:.include?(File.dirname(__FILE__+"\\..")) || $:.include?(File.expand_path(File.dirname(__FILE__+"\\..")))


require 'FileSystem'
 #Disk image in ProDOS format
class ProDos<FileSystem

def self.host_system
  Apple2
end  

#block $02 - bytes $00/$01 are both $00, byte $04 is $F?, 
#bytes $29-$2A = number of sectors ( 0x118 on a 35 track 5.25" disk)
is_valid_file_system_if lambda {
  first_sector_in_block_2=file_system_image.get_sector(0,4)
  ((!first_sector_in_block_2.nil?) &&  (first_sector_in_block_2[0..1]=="\x00\x00") &&
    (first_sector_in_block_2[4]>=0xF0) &&
    (first_sector_in_block_2[0x29]+first_sector_in_block_2[0x2a]*0x100==file_system_image.track_count*8)
  )
  }

#returns a FileContainer of of the native files contained in file system image

def self.files(file_system_image)  
  files=FileContainer.new
  ProDos.read_catalog(file_system_image,2,"").flatten.each do |file|
    files<<file
  end
  files
end

private

def self.get_block(file_system_image,block_no)
		track=(block_no / 8).to_i
		first_sector=2*(block_no % 8)
		raise "illegal block no #{block_no}" if track>=file_system_image.track_count
		return file_system_image.get_sector(track,first_sector)+file_system_image.get_sector(track,first_sector+1)
	end
  
def self.read_catalog(file_system_image,starting_block,dir_path)
  files=FileContainer.new
  next_block_no=starting_block
  while (next_block_no!=0)
    block=ProDos.get_block(file_system_image,next_block_no)
    offset=4
    while (offset<(0x200-0x27))
      directory_entry=block[offset..offset+0x27]
      storage_type=directory_entry[0]>>4
      name_length=directory_entry[0]%0x10
      name=directory_entry[1..name_length]
      file_type=directory_entry[0x10]
      key_pointer=directory_entry[0x11]+directory_entry[0x12]*0x100
      blocks_used=directory_entry[0x13]+directory_entry[0x14]*0x100
      file_length=directory_entry[0x15]+directory_entry[0x16]*0x100+directory_entry[0x17]*0x10000
      aux_code=directory_entry[0x1f]+directory_entry[0x20]*0x100
      full_filename="#{dir_path}#{name}"
      case storage_type
        when 0x00 then
          #nop
        when 0x01 then  #it's a seedling
          file_contents=ProDos.get_block(file_system_image,key_pointer)            
          files<<NativeFileType.best_fit(file_system_image,full_filename,file_contents,file_type,aux_code)
          #files<<ProDOSFile.new(name,file_contents,file_type,aux_code,full_filename)
        when 0x02 then  #it's a sapling
          block_list=[]
          index_block=get_block(file_system_image,key_pointer)
          0.upto((file_length/0x200)) do |i|
            block_list<<index_block[i]+(index_block[i+0x100]*0x100)
          end
          file_contents=""
          block_list.each do |next_block_no|
            if next_block_no==0 then
              file_contents+="\x00"*0x200
            else
              file_contents+=get_block(file_system_image,next_block_no)
            end
          end
          file_contents=file_contents[0..file_length-1]            
          files<<NativeFileType.best_fit(file_system_image,full_filename,file_contents,file_type,aux_code)
        when 0x03 then  #it's a tree
          master_index_block=get_block(file_system_image,key_pointer)
          block_list=[]
          number_of_index_entries=1+(file_length/0x200)
          number_of_index_blocks=1+(number_of_index_entries/0x100)
          number_of_index_entries_in_last_block=number_of_index_entries-(number_of_index_blocks-1)*0x100
          0.upto(number_of_index_blocks-1) do |i|
            index_block_no=master_index_block[i]+master_index_block[i+0x100]*0x100
            index_block=get_block(file_system_image,index_block_no)
            if i==number_of_index_blocks-1 then 
              entries_in_this_index_block=number_of_index_entries_in_last_block
            else 
              entries_in_this_index_block=256
            end
            0.upto(entries_in_this_index_block-1) do |j|
              block_list<<index_block[j]+(index_block[j+0x100]*0x100)
            end
          end
          file_contents=""
          block_list.each do |next_block_no|
            if next_block_no==0 then
              file_contents+="\x00"*0x200
            else
              file_contents+=get_block(file_system_image,next_block_no)
            end
          end
          file_contents=file_contents[0..file_length-1]
          files<<NativeFileType.best_fit(file_system_image,full_filename,file_contents,file_type,aux_code)
        when 0x0D then 	#it's a subdirectory pointer
          files+=read_catalog(file_system_image,key_pointer,"#{dir_path}#{name}/")
        when 0x0E then 	#it's a subdirectory header
          #do nothing 
        when 0x0F then 	#it's a volume						
          @volume_name=name 
        else 
          RipXploreLog.warn("skipping unknown storage_type #{sprintf '%02X',storage_type} for #{dir_path}#{name}")
      end			
      offset+=0x27
    end
    next_block_no=block[2]+block[3]*256
  end
  files
end
  
end

  
# == Author
# Jonno Downes (jonno@jamtronix.com)
#
# == Copyright
# Copyright (c) 2008 Jonno Downes (jonno@jamtronix.com)
#
#Permission is hereby granted, free of charge, to any person obtaining
#a copy of this software and associated documentation files (the
#"Software"), to deal in the Software without restriction, including
#without limitation the rights to use, copy, modify, merge, publish,
#distribute, sublicense, and/or sell copies of the Software, and to
#permit persons to whom the Software is furnished to do so, subject to
#the following conditions:

# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.