farski/periodic

require 'bigdecimal'

module Periodic
  module Duration
    module Units
      TIME = Hash.new
      TIME[:seconds] = { :factor => 1, :directive => /%s/ }
      TIME[:minutes] = { :factor => 60, :directive => /%m/ }
      TIME[:hours] = { :factor => 3600, :directive => /%h/ }
      TIME[:days] = { :factor => 3600*24, :directive => /%d/ }
      # TIME[:weeks] = { :factor => 3600*24*7, :directive => /%w/ }
      # TIME[:months] = { :factor => 3600*24*30, :directive => /%n/ }
      TIME[:years] = { :factor => 3600*24*365, :directive => /%y/ }

      TIME_ORDER = [:seconds, :minutes, :hours, :days, :years] # not working with weeks and months...
    end

    def self.sanitize_formatted_string(string)
      if string.match(/:/) && !string.match(/[a-zA-Z ]/)
        # add leading zeros where missing...
        string.gsub!(/!(\d):/, '!0\1:')
        string.gsub!(/^(\d):/, '0\1:')
        string.gsub!(/:(\d):/, ':0\1:')
        string.gsub!(/:(\d):/, ':0\1:') # needs to happen twice??
        string.gsub!(/:(\d(.\d)*)$/, ':0\1')

        # remove leading zero-value digitals
        string.sub!(/[0:]*/, '')
      else
        # if the string starts with a number we can assume the value-label pairs are like '10 minutes'
        if string[0,1].match(/\d/) || string[0,1] == "!"
          string = string.split(/(!?\d[.\d]*[-_:, a-zA-Z]+)/).delete_if{|x| x == ""}.inject(String.new) { |memo, s| memo << ((s.match(/!/) || s.match(/[1-9]/)) ? s : "")  }

        # if starts with a letter we can assume the value-label pairs are like 'minutes: 10'
        else
          string = string.split(/([-A-Za-z: ,]+\d[.\d]*)/).delete_if{|x| x == ""}.inject(String.new) { |memo, s| memo << ((s.match(/!/) || s.match(/[1-9]/)) ? s : "")  }
          string.sub!(/([ ,])*([a-zA-Z]+)/, '\2')
        end

        # remove leading zero-value digitals
        string.sub!(/[0:]*/, '')
      end
      string.strip.gsub(/!/, '')
    end

    class Duration
      def initialize(seconds)
        @seconds = (seconds.is_a?(Float) ? seconds.to_f : seconds)
      end

      def format(format = '%y:%d:%h:%m:%s', precision = nil)
        string, nondirective_units, values, smallest_unit_directive = format, [], Hash.new, nil

        Periodic::Duration::Units::TIME_ORDER.reverse.each_with_index do |unit, i|
          if format =~ Periodic::Duration::Units::TIME[unit][:directive]
            values[unit] = send(unit) + nondirective_units.inject(0) { |total, u| total += (send(u) * (Periodic::Duration::Units::TIME[u][:factor] / Periodic::Duration::Units::TIME[unit][:factor])) }
            smallest_unit_directive = unit
            nondirective_units.clear
          else
            nondirective_units << unit if (send(unit) > 0)
          end

          # correct for any left over time that's is fractional for all the included units
          values[smallest_unit_directive] += nondirective_units.inject(0) { |total, u| total += (send(u).to_f * Periodic::Duration::Units::TIME[u][:factor] / Periodic::Duration::Units::TIME[smallest_unit_directive][:factor]) } if (!Periodic::Duration::Units::TIME_ORDER.reverse[i+1] && !nondirective_units.empty?)
        end

        values[smallest_unit_directive] = case precision
          when nil then (values[smallest_unit_directive] % 1 == 0) && !@seconds.is_a?(Float) ? values[smallest_unit_directive].to_i : values[smallest_unit_directive]
          when 0 then values[smallest_unit_directive].to_i
          else (values[smallest_unit_directive] * (10 ** precision)).round / (10 ** precision).to_f
        end

        return Periodic::Duration.sanitize_formatted_string(values.inject(string) { |str, data| str.sub!(Periodic::Duration::Units::TIME[data[0]][:directive], data[1].to_s) })
      end

      Periodic::Duration::Units::TIME_ORDER.each_with_index do |unit, i|
        define_method("in_" + unit.to_s) { @seconds.to_f / Periodic::Duration::Units::TIME[unit][:factor] }
        define_method("whole_" + unit.to_s) { (@seconds.to_f / Periodic::Duration::Units::TIME[unit][:factor]).floor }
        define_method(unit) { ((Periodic::Duration::Units::TIME_ORDER[i+1] ? BigDecimal.new(@seconds.to_f.to_s) % BigDecimal.new(Periodic::Duration::Units::TIME[Periodic::Duration::Units::TIME_ORDER[i+1]][:factor].to_f.to_s) : @seconds.to_f) / Periodic::Duration::Units::TIME[unit][:factor].to_f).send(unit == :seconds ? :to_f : :floor) }
      end
    end
  end
end