$:.unshift(File.dirname(__FILE__)) unless
	$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
require 'open-uri'
require 'RipXploreLog'

class FileSystemImage

attr_reader :file_system, :image_format,:filename
attr_accessor :volume_name

def FileSystemImage.is_file_system_image_filename?(filename)
  
  extension=File.extname(File.basename(filename,".gz")).downcase
  RipXploreLog.debug("checking if is file system image filename - #{filename} (extension #{extension})")
  RipXploreLog.debug(ImageFormat.all_possible_extensions.join(";"))
  ImageFormat.all_possible_extensions.include?(extension)
end

#given a bytestream (and, optionally, filename the bytes are from), return the class that is the best match for this class
def FileSystemImage.best_fit(file_bytes,filename=nil)
  candidates=[]
  file_ext=File.extname(filename.sub(/\.gz$/,"")).downcase
  RipXploreLog.debug("looking for best fit for image format for #{filename} : extension #{file_ext}")
  ImageFormat.all_image_formats.each do |image_format|
    if !file_ext.nil? && !image_format.possible_extensions.include?(file_ext) then
      RipXploreLog.debug("skipping #{image_format} - unmatched extension #{file_ext}")
    else
      image_format.possible_file_systems.each do |file_system|
        RipXploreLog.debug("checking image format #{image_format} and file system #{file_system}")
        candidate=FileSystemImage.new(file_bytes,file_system,image_format,filename)
        RipXploreLog.debug("score - #{candidate.compatability_score}")
        candidates<<candidate
      end
    end    
  end
  
  
  if candidates.length==0 then
    RipXploreLog.debug( 'no valid combination of file system and image format found')
    return nil
  end
  best_candidate=candidates.sort{|a,b| b.compatability_score<=>a.compatability_score}[0]
  RipXploreLog.debug("best candidate = #{best_candidate.file_system}/#{best_candidate.image_format} score: #{best_candidate.compatability_score}")
  best_candidate
end

@compatability_score=nil
def compatability_score
  if @compatability_score.nil? then
    image_format_compatability_score=image_format.compatability_score(self)    
    if image_format_compatability_score>0 then #if we don't have a valid image_format, don't bother checking the file_system!
      file_system_compatability_score=file_system.compatability_score(self)
      @compatability_score=file_system_compatability_score*image_format_compatability_score
    else
      @compatability_score=0
    end
  end
  @compatability_score
end

def file_bytes
    return image_format.file_bytes
end

def get_sector(track,sector)
  image_format.get_sector(track,sector)
end

def set_sector(track,sector,sector_contents)
  raise "#{image_format} image updates not supported (yet)" unless image_format.respond_to?(:set_sector)
  image_format.set_sector(track,sector,sector_contents)
end

#how many tracks are in this particular image?
def track_count
  image_format.track_count
end

def initialize(file_bytes,file_system,image_format,filename=nil)
  @file_bytes=file_bytes
  @file_system=file_system
  @image_format=image_format.new(file_bytes)
  @filename=filename
  @files=file_system.files(self) if compatability_score>0
end


  def files
    @files=file_system.files(self) if @files.nil?
    @files.flatten
  end

#return an array containing a list of numbers of valid tracks on this image
 def track_list
    image_format.track_list
end


 #return a list of all valid sectors in the specified track on this image
 def sectors_in_track(track_no)
  image_format.sectors_in_track(track_no)
end

def start_track
  image_format.host_system.start_track
end

def end_track
  image_format.end_track
end

def to_hex_dump
		s=""   
		track_list.each {|track| s<<dump_track(track)}
		s
  end
  
  #return a formatted hex dump of a single 256 byte sector
	def dump_sector(track,sector)
  	s=hline
		s<<sprintf("TRACK: $%02X SECTOR $%02X\n",track,sector)
		sector_data=get_sector(track,sector)
		s<< file_system.host_system.hex_dump(sector_data)
		s
	end

#return a formatted hex dump of all sectors in a track
  def dump_track(track)
    s=""
      sectors_in_track(track).each do |sector|
				s<<dump_sector(track,sector)
			end
    s
	end

def host_system
  file_system.host_system
end

#produce a list of all files contained in this file system images
def catalog
  s="\n%-32s %-16s %04s   %s\n\n" % ["FILENAME","TYPE","LENGTH","LOAD ADDRESS"]
  self.files.sort.each do |file|      
    raise "bogus file '#{file.filename}'" if file.contents.nil?
    contents_length= (file.contents.respond_to?(:length) ? file.contents.length : 0)
    s<<"%-32s %-16s $%04x    $%04x\n" % [file.filename,file.type_description,contents_length,file.load_address]
  end
  s
end

#produce a detailed description of everything we know about this disk and the files on it
def to_info_dump
  s=""
  self.files.sort.each do |file|
    s<<"--------------------------------------------\n#{file.filename} (#{file.class})\n"
  	s<<file.to_info_dump
  end
  s
end

def save_as(filename)
    if !(filename=~/\.gz$/).nil? then
			require 'zlib'
      f=Zlib::GzipWriter.new(open(filename,"wb"))
    else
      f=open(filename,"wb")
    end    
    f<<file_bytes
    f.close
  end


def pictures
  files.find_all{|f| f.respond_to?(:to_picture)}
end

def fonts
  files.find_all{|f| f.respond_to?(:to_font)}
end

def texts
  files.find_all{|f| f.respond_to?(:to_text)}
end

def listings
  files.find_all{|f| f.respond_to?(:to_listing)}
end

def add_file(native_filetype_class_symbol,filename,file_contents,file_type=nil,aux_code=nil)
  raise "#{file_system} image updates not supported (yet)" unless file_system.respond_to?(:add_file)
  begin
    native_filetype_class=eval("#{native_filetype_class_symbol}")
  rescue 
    raise "#{native_filetype_class_symbol} is not a valid file type. Valid file types for #{file_system} are:\n\t"+NativeFileType.native_file_types_possible_on_file_system(file_system).join("\n\t")
  end

  file=file_system.add_file(self,native_filetype_class,filename,file_contents,file_type,aux_code)
  @files=nil #force a reread of the catalog 
  file
end

def delete_file(filename)
  raise "#{file_system} image updates not supported (yet)" unless file_system.respond_to?(:delete_file)
  file_system.delete_file(self,filename)
  @files=nil #force a reread of the catalog 
end

private

	def hline
		"-"*79+"\n"
	end

end

FileSystemImage.extend SubclassTracking
  
# == 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.