$:.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'
#
#
class CbmDos<FileSystem

def self.host_system
  C64
end  

DIRECTORY_ENTRY_SIZE=0x20
FILE_TYPES=[:del,:seq,:prg,:usr,:rel,:unk,:unk,:unk]
GEOS_FILE_TYPES=[:not_geos,:basic,:assembler,:data,:system,:desk_accessory,:application,:application_data,:font,:printer_driver,:input_driver,:disk_driver,:system_boot,:temp,:autoexec]
#for now, assume that anything on a CBM compatable disk image format is a CBM DOS
is_valid_file_system_if lambda {file_system_image.image_format.respond_to?(:dir_track_no)}

def self.files(file_system_image)
  files=FileContainer.new
  dir_track_no=file_system_image.image_format.dir_track_no
  dir_sector_no=file_system_image.image_format.dir_sector_no
  until dir_track_no==0 || dir_track_no> file_system_image.end_track do 
    directory_sector=file_system_image.get_sector(dir_track_no,dir_sector_no)        
    dir_track_no=directory_sector[0]
    dir_sector_no=directory_sector[1]
    0.upto(7) do |entry_number|            
        directory_entry=directory_sector[DIRECTORY_ENTRY_SIZE*entry_number,DIRECTORY_ENTRY_SIZE]
        file_name=C64.s_to_ascii(directory_entry[0x05..0x14]).strip
        next if directory_entry[0x02]==0x00 #skip SCRATCHed files
        file_type=FILE_TYPES[directory_entry[0x02]%8]
        geos_file_type=GEOS_FILE_TYPES[directory_entry[0x18]]
        is_geos_file=(geos_file_type!=:not_geos)
        is_vlir=is_geos_file && (directory_entry[0x17]==0x01)
#        puts "geos file type: #{geos_file_type} #{is_geos_file} #{is_vlir}"
        file_track_no=directory_entry[0x03]
        file_sector_no=directory_entry[0x04]
        if (is_geos_file) then
        	file_name=(directory_entry[0x05..0x14]).gsub(/\xa0/," ").strip #GEOS filenames will be ASCII not PETSCII
        	info_block=file_system_image.get_sector(directory_entry[0x15],directory_entry[0x16])
        	file_contents=[info_block]
        	
        end
        if (is_vlir) then    	
 #       	puts file_name
        	record_block=file_system_image.get_sector(file_track_no,file_sector_no)
        	127.times do |i|
	        	record_no=i+1
	        	record_track_no=record_block[2*record_no]
    	    	record_sector_no=record_block[1+(2*record_no)]
    	    	record_contents=nil
        		until record_track_no==0 || record_track_no>file_system_image.end_track do
        			record_contents="" if record_contents.nil?
			  		record_sector=file_system_image.get_sector(record_track_no,record_sector_no)          
			  		break if record_sector.nil?
			  		record_track_no=record_sector[0]
			 		record_sector_no=record_sector[1]
			  		end_of_data= (record_track_no==0) ? record_sector[1] : 255
			  		record_contents<<record_sector[2..end_of_data]
				end
				file_contents<<(record_contents)
        	end
        else
			file_contents=""
			until file_track_no==0 || file_track_no> file_system_image.end_track do
			  file_sector=file_system_image.get_sector(file_track_no,file_sector_no)          
			  break if file_sector.nil?
			  file_track_no=file_sector[0]
			  file_sector_no=file_sector[1]
			  end_of_data= (file_track_no==0) ? file_sector[1] : 255
			  file_contents+=file_sector[2..end_of_data]
	#          puts "#{file_name} #{file_track_no} #{file_sector_no} #{end_of_data}"
			end
        end
        file=NativeFileType.best_fit(file_system_image,file_name,file_contents,file_type,geos_file_type)
        file.meta_data["c64_file_type"]="$%02x" % directory_entry[0x02]
        file.meta_data["first_block"]="track $%02x sector $%02x" % [directory_entry[0x03],directory_entry[04]]
        if (is_geos_file) then
        	file.meta_data["geos_file_header"]="track $%02x sector $%02x" % [directory_entry[0x15],directory_entry[16]]
        	file.meta_data["geos_file_structure_type"]="$%02x" % directory_entry[0x17]
        	file.meta_data["geos_file_type"]="$%02x" % directory_entry[0x18]
        	file.meta_data["geos_file_modified_date"]="%04d-%02d-%02d %02d:%02d" % [1900+directory_entry[0x19],directory_entry[0x1A],directory_entry[0x1B],directory_entry[0x1C],directory_entry[0x1D]]
        end
        files<<file
    end
  end
  files
end

#iterate through the BAM (Block Availability Map), return a list of [track,sector] for sectors marked available
def self.free_sector_list(file_system_image)
  bam=file_system_image.get_sector(18,0)
  free_sectors=[]
    (1..35).each do |track|
      next if track==18 #don't try to save files to track 18
      track_bitmap_lo=bam[track*4+1]
      track_bitmap_mid=bam[track*4+2]
      track_bitmap_hi=bam[track*4+3]
      (0..7).each do |bit_no|
        if ((track_bitmap_lo & (2**(bit_no)))!=0) then
          free_sectors<<[track,bit_no]
        end
        if ((track_bitmap_mid & (2**(bit_no)))!=0) then
          free_sectors<<[track,bit_no+8]
        end
        if ((track_bitmap_hi & (2**(bit_no)))!=0) then
          free_sectors<<[track,bit_no+16]
        end                
      end
    end
    free_sectors.sort!
#    free_sectors.each {|ts| puts "T#{ts[0]} S#{ts[1]}"}
end

def self.directory_entry_for_filename(filename)
  (filename+(0xA0.chr)*16)[0,0x10]
end  

def self.add_file(file_system_image,native_filetype_class,filename,file_contents,file_type=nil,aux_code=nil)
  #make sure the file type is supported on CBM DOS!
  raise "#{native_filetype_class} not supported on CBM DOS 2.6 file system" if  native_filetype_class.file_system_file_types[self].nil?
  expected_file_type=native_filetype_class.file_system_file_types[self] 
  file_type=expected_file_type if file_type.nil?
  raise "inconsistent file_type (should be #{expected_file_type} but was #{file_type})" unless expected_file_type==file_type
  native_file=native_filetype_class.new(file_system_image,filename,file_contents,file_type,aux_code)
  raise "couldn't make #{native_filetype_class}" if native_file.nil?
  
  file_system_image.delete_file(filename) unless file_system_image.files[filename].nil?

  
  free_sectors=free_sector_list(file_system_image)
  sectors_needed=1+(file_contents.length/254)
  file_sectors=free_sectors[(free_sectors.length-sectors_needed)/2,sectors_needed] #we take a chunk out of the middle of the available sectors, so we keep as close to track 18 as possible
  raise "not enough free space - #{sectors_needed} sectors needed, #{file_sectors.length} available " unless sectors_needed==file_sectors.length  
  directory_slot=find_free_directory_slot(file_system_image)
#  file_sectors.each {|ts| puts "T#{ts[0]} S#{ts[1]}"}
  directory_slot=create_empty_directory_sector(file_system_image) if directory_slot.nil?
  raise "DIRECTORY IS FULL!" if directory_slot.nil?
  raise "invalid directory slot " if directory_slot[2].nil?
#  puts "T#{directory_slot[0]} S#{directory_slot[1]} OFFSET #{directory_slot[2]}"
  directory_track_no=directory_slot[0]
  directory_sector_no=directory_slot[1]
  directory_offset=directory_slot[2]
  directory_sector=file_system_image.get_sector(directory_track_no,directory_sector_no)
  directory_filename=directory_entry_for_filename(filename)
  file_code=FILE_TYPES.index(native_file.class.file_system_file_types[CbmDos])
  raise "invalid file type" if file_code.nil?
  file_code+=0x80 unless file_code==0 #DEL files should be OPEN, all other files should be CLOSED
#  puts "%x" % file_code
  directory_entry=[file_code,file_sectors[0][0],file_sectors[0][1],directory_filename,file_sectors.length].pack("CCCa16x9v")
#  puts "start of file #{filename} will be T #{file_sectors[0][0]} S #{file_sectors[0][1]}"
  sectors_needed.times do |i|
    this_track_no=file_sectors[i][0]
    this_sector_no=file_sectors[i][1]
    if i==(sectors_needed-1) then
      next_track_no=0
      data_length=(file_contents.length % 254)
      next_sector_no=data_length+1
    else
      next_track_no=file_sectors[i+1][0]
      next_sector_no=file_sectors[i+1][1]
      data_length=254
    end
    sector_data=[next_track_no,next_sector_no,file_contents[i*254,data_length] ].pack("CCA254")
    file_system_image.set_sector(this_track_no,this_sector_no,sector_data)
    mark_sector_as_used(file_system_image,this_track_no,this_sector_no)
  end
  directory_sector[directory_offset+2,0x1D]=directory_entry #skip over the first 2 bytes, which are the track / sector of next directory sector in slot 1, or 0/0 in other slots
  file_system_image.set_sector(directory_track_no,directory_sector_no,directory_sector)
  return native_file
end

#iterate through the directory to find either the named file or (if nil is passed in) an empty slot
def self.find_free_directory_slot(file_system_image)
  directory_track_no=18
  directory_sector_no=1  
  while (directory_track_no !=0) do
    directory=file_system_image.get_sector(directory_track_no,directory_sector_no)    
    raise "attempted to read invalid directory sector at T #{directory_track_no} S#{directory_sector_no}" if directory.nil?
    8.times do |slot_no|
      slot_start=slot_no*0x20
      if (directory[slot_start+2]==0x00) || (directory[slot_start+2]==0xFF) then        
        return [directory_track_no,directory_sector_no,slot_start]
      end
    end
    directory_track_no=directory[00]
    directory_sector_no=directory[01]    
  end
  nil
end

def self.mark_sector_as_used(file_system_image,track_no,sector_no)
  bam=file_system_image.get_sector(18,0)
  bam_entry_offset=track_no*4
  sector_offset=sector_no/8
  bitmask=2**(sector_no % 8)
  existing_bam_byte=bam[bam_entry_offset+sector_offset+1]
#  puts "T #{"%02x"% track_no} S #{"%02x"% sector_no} L #{"%02x"% bam_entry_offset} sector_offset #{sector_offset} mask #{"%08b" % bitmask} was #{"%08b" % existing_bam_byte}"
  if (existing_bam_byte & bitmask)==(bitmask) then
    bam[bam_entry_offset+sector_offset+1]-=bitmask
    bam[bam_entry_offset]-=1
    file_system_image.set_sector(18,0,bam)    
  end
end
def self.mark_sector_as_free(file_system_image,track_no,sector_no)
  bam=file_system_image.get_sector(18,0)
  bam_entry_offset=track_no*4
  sector_offset=sector_no/8
  bitmask=2**(sector_no % 8)
  existing_bam_byte=bam[bam_entry_offset+sector_offset+1]
#  puts "T #{"%02x"% track_no} S #{"%02x"% sector_no} L #{"%02x"% bam_entry_offset} sector_offset #{sector_offset} mask #{"%08b" % bitmask} was #{"%08b" % existing_bam_byte}"
  if (existing_bam_byte & bitmask)!=(bitmask) then
    bam[bam_entry_offset+sector_offset+1]+=bitmask
    bam[bam_entry_offset]+=1
    file_system_image.set_sector(18,0,bam)
  end

end

def self.create_empty_directory_sector(file_system_image)
  directory_track_no=18
  directory_sector_no=1
  candidate_sectors=file_system_image.sectors_in_track(directory_track_no)-[0,1]
  while (directory_track_no ==18) do
    candidate_sectors-=[directory_sector_no]
    directory=file_system_image.get_sector(directory_track_no,directory_sector_no)    
    raise "attempted to read invalid directory sector at T #{directory_track_no} S#{directory_sector_no}" if directory.nil?
    next_directory_track_no=directory[00]
    next_directory_sector_no=directory[01]
    if (next_directory_track_no==0) && (candidate_sectors.length>0) then
      next_directory_sector_no = (candidate_sectors.include?(directory_sector_no+3) ? directory_sector_no+3 : candidate_sectors[0])
      directory[00]=18
      directory[01]=next_directory_sector_no
      file_system_image.set_sector(directory_track_no,directory_sector_no,directory)
      file_system_image.set_sector(directory_track_no,next_directory_sector_no,(0.chr)*256) #reset the directory sector we just added
      mark_sector_as_used(file_system_image,directory_track_no,next_directory_sector_no)
      return [directory_track_no,next_directory_sector_no,0] 
    end
    directory_sector_no=next_directory_sector_no
    directory_track_no=next_directory_track_no
  end
  nil
end

  def self.delete_file(file_system_image,filename)
  directory_filename=directory_entry_for_filename(filename)
  #first find this file's directory entry
  directory_track_no=18
  directory_sector_no=1  
  while (directory_track_no !=0) do
    directory=file_system_image.get_sector(directory_track_no,directory_sector_no)    
    raise "attempted to read invalid directory sector at T #{directory_track_no} S#{directory_sector_no}" if directory.nil?
    8.times do |slot_no|
      slot_start=slot_no*0x20
      next if directory[slot_start+2]==0 #skip files that are already deleted
      if directory[slot_start+5,16]==directory_filename then
        #found our file!
#        puts "found #{filename} at T #{directory_track_no} S #{directory_sector_no} slot #{slot_no}"

        #clear the directory entry
        directory[slot_start+2]=0
        file_system_image.set_sector(directory_track_no,directory_sector_no,directory)
        #now mark the file sectors as being free in the BAM
        file_track_no=directory[slot_start+3]
        file_sector_no=directory[slot_start+4]
        
        until (file_track_no==0) do
#          puts "freeing T #{file_track_no} S #{file_sector_no}"
          mark_sector_as_free(file_system_image,file_track_no,file_sector_no)
          file_sector=file_system_image.get_sector(file_track_no,file_sector_no)
          file_track_no=file_sector[0]
          file_sector_no=file_sector[1]
        end
        return
      end
    end
    directory_track_no=directory[00]
    directory_sector_no=directory[01]    
  end
end

end
  
# == Author
# Jonno Downes (jonno@jamtronix.com)
#
# == Copyright
# Copyright (c) 2008,2009 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.