require "real_zip/version"

require 'yaml'
require 'forwardable'
require 'zip/zipfilesystem'
require 'fileutils'
require 'pry'

def RealZip file, structure
  RealZip.new file, structure
end

module RealZip

  ####################

  module Helpers
    extend self

    def traverse array_or_hash, path=[], &block
      given = array_or_hash
      case given
      when Hash
        given.each_pair do |k,v|
          block.call path+[k], :dir # entering directory
          traverse v,path+[k],&block
        end
      when Array then given.each { |x| traverse x,path,&block }
      else
        block.call path+[given], :file
      end
    end

    def collect_all(given)
      found = []
      traverse given do |x,y| found << [x,y] end
      found
    end
    def collect_only(given, kind)
      collect_all(given).map { |(name,type)| name if type == kind }.compact
    end    
    def files(given)
      collect_only(given, :file).map { |x| x.join ?/ }
    end
    def dirs(given)
      collect_only(given, :dir).map { |x| x.join ?/ }
    end

    def is_file(file)
      File.file?(file)
    end     
  end 

  ####################

  class RealZip < Struct.new :file_structure  
    def save file
      File.delete file if File.exist? file
      Zip::ZipFile.open file, Zip::ZipFile::CREATE do |z|
        # first_dir = nil
        dirs(struct).each do |dir|
          first_dir = dir
          z.dir.mkdir(dir) unless z.file.exist? dir
        end

        hash =  struct 
        hash.each do |dir,file_arr|
          new_files = files({dir => file_arr})
          new_files.each_with_index do |file, index|
            orignal_file_path = file_arr[index]
            if File.directory?(orignal_file_path)
              puts "..... directory found ......"
              source = "#{orignal_file_path}"
              # directory_name = source.split('/').last
              Dir.glob("#{source}**/*").reject {|fn| File.directory?(fn) }.each do |file|
                string  = File.open(file, 'r'){ |f| f.read }
                destination_path = file.sub(source, '' )
                destination_path = "#{dir.to_s}/#{destination_path}"
                puts "adding file    #{destination_path} ..."
                z.file.open(destination_path, "w") { |f| f.write string }
              end
            else
              puts "..... File found ......"  
              string  = File.open(orignal_file_path, 'r'){ |f| f.read }
              file_name = file.split('/').last
              new_file_name = ( files( {dir => [ "#{file_name}" ] } ) ).first
              z.file.open(new_file_name, "w") { |f| f.write string }
            end 
          end
        end 
      end
    end

    def struct given=file_structure
      given.is_a?(String) ? YAML.load(given) : given
    end

    private

    extend Forwardable
    def_delegators Helpers, :files, :dirs   
  end

  def new file, structure
    RealZip.new(structure).save file
  end

  module_function :new  
end


__END__
# Other tests...

found = []
RealZip::Helpers.traverse( {a: [{a: 1, b: 2}, 3]}, &proc{ |x| found << x } )
found.map { |x| x.join ?/ } == ["a", "a/a", "a/a/1", "a/b", "a/b/2", "a/3"] or raise

RealZip::Helpers.files({a: [{a: 1, b: 2}, 3]}) == %w[ a/a/1  a/b/2  a/3 ] or raise


require 'yaml'

raise unless RealZip('empty_dir: []').contents == {'empty_dir' => []}
raise unless RealZip('dir: [file1, file2]').contents == {'dir' => ['file1','file2']}

tree = 'root_dir: [file1, file2, nested_dir: []]'
raise unless RealZip(tree).contents == {'root_dir' => ['file1','file2',{'nested_dir' => [] }]}

file_name = 'temp-test-Real.zip'
tree = 'root_dir: [file1, file2, nested_dir: [nested_file.any], empty_dir: []]'
RealZip(tree).save file_name

Zip::ZipFile.open file_name do |z|
  z.file.exist? 'root_dir/file1' or raise
  z.file.exist? 'root_dir/file2' or raise
  z.file.exist? 'root_dir/nested_dir/nested_file.any' or raise
  z.file.exist? 'root_dir/empty_dir' or raise # no empty dirs
end 
File.delete file_name