class Mail::Multibyte::Chars

def self.consumes?(string)
  # Unpack is a little bit faster than regular expressions.
  string.unpack('U*')
  true
rescue ArgumentError
  false
end

def self.wants?(string)
  $KCODE == 'UTF8' && consumes?(string)
end

def +(other)
  chars(@wrapped_string + other)
end

def <=>(other)
  @wrapped_string <=> other.to_s
end

def =~(other)
  translate_offset(@wrapped_string =~ other)
end

def =~(other)
  @wrapped_string =~ other
end

def []=(*args)
  replace_by = args.pop
  # Indexed replace with regular expressions already works
  if args.first.is_a?(Regexp)
    @wrapped_string[*args] = replace_by
  else
    result = Unicode.u_unpack(@wrapped_string)
    if args[0].is_a?(Fixnum)
      raise IndexError, "index #{args[0]} out of string" if args[0] >= result.length
      min = args[0]
      max = args[1].nil? ? min : (min + args[1] - 1)
      range = Range.new(min, max)
      replace_by = [replace_by].pack('U') if replace_by.is_a?(Fixnum)
    elsif args.first.is_a?(Range)
      raise RangeError, "#{args[0]} out of range" if args[0].min >= result.length
      range = args[0]
    else
      needle = args[0].to_s
      min = index(needle)
      max = min + Unicode.u_unpack(needle).length - 1
      range = Range.new(min, max)
    end
    result[range] = Unicode.u_unpack(replace_by)
    @wrapped_string.replace(result.pack('U*'))
  end
end

def acts_like_string?
  true
end

def capitalize
  (slice(0) || chars('')).upcase + (slice(1..-1) || chars('')).downcase
end

def center(integer, padstr=' ')
  justify(integer, :center, padstr)
end

def chars(string) #:nodoc:
  self.class.new(string)
end

def compose
  chars(Unicode.compose_codepoints(Unicode.u_unpack(@wrapped_string)).pack('U*'))
end

def decompose
  chars(Unicode.decompose_codepoints(:canonical, Unicode.u_unpack(@wrapped_string)).pack('U*'))
end

def downcase
  chars(Unicode.apply_mapping(@wrapped_string, :lowercase_mapping))
end

def g_length
  Unicode.g_unpack(@wrapped_string).length
end

def include?(other)
  # We have to redefine this method because Enumerable defines it.
  @wrapped_string.include?(other)
end

def index(needle, offset=0)
  wrapped_offset = first(offset).wrapped_string.length
  index = @wrapped_string.index(needle, wrapped_offset)
  index ? (Unicode.u_unpack(@wrapped_string.slice(0...index)).size) : nil
end

def initialize(string)
  @wrapped_string = string
  @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
end

def initialize(string) #:nodoc:
  @wrapped_string = string
end

def insert(offset, fragment)
  unpacked = Unicode.u_unpack(@wrapped_string)
  unless offset > unpacked.length
    @wrapped_string.replace(
      Unicode.u_unpack(@wrapped_string).insert(offset, *Unicode.u_unpack(fragment)).pack('U*')
    )
  else
    raise IndexError, "index #{offset} out of string"
  end
  self
end

def justify(integer, way, padstr=' ') #:nodoc:
  raise ArgumentError, "zero width padding" if padstr.length == 0
  padsize = integer - size
  padsize = padsize > 0 ? padsize : 0
  case way
  when :right
    result = @wrapped_string.dup.insert(0, padding(padsize, padstr))
  when :left
    result = @wrapped_string.dup.insert(-1, padding(padsize, padstr))
  when :center
    lpad = padding((padsize / 2.0).floor, padstr)
    rpad = padding((padsize / 2.0).ceil, padstr)
    result = @wrapped_string.dup.insert(0, lpad).insert(-1, rpad)
  end
  chars(result)
end

def limit(limit)
  slice(0...translate_offset(limit))
end

def ljust(integer, padstr=' ')
  justify(integer, :left, padstr)
end

def lstrip
  chars(@wrapped_string.gsub(Unicode::LEADERS_PAT, ''))
end

def method_missing(method, *args, &block)
  if method.to_s =~ /!$/
    @wrapped_string.__send__(method, *args, &block)
    self
  else
    result = @wrapped_string.__send__(method, *args, &block)
    result.kind_of?(String) ? chars(result) : result
  end
end

def normalize(form = nil)
  chars(Unicode.normalize(@wrapped_string, form))
end

def ord
  Unicode.u_unpack(@wrapped_string)[0]
end

def padding(padsize, padstr=' ') #:nodoc:
  if padsize != 0
    chars(padstr * ((padsize / Unicode.u_unpack(padstr).size) + 1)).slice(0, padsize)
  else
    ''
  end
end

def respond_to?(method, include_private=false)
  super || @wrapped_string.respond_to?(method, include_private) || false
end

def reverse
  chars(Unicode.g_unpack(@wrapped_string).reverse.flatten.pack('U*'))
end

def rindex(needle, offset=nil)
  offset ||= length
  wrapped_offset = first(offset).wrapped_string.length
  index = @wrapped_string.rindex(needle, wrapped_offset)
  index ? (Unicode.u_unpack(@wrapped_string.slice(0...index)).size) : nil
end

def rjust(integer, padstr=' ')
  justify(integer, :right, padstr)
end

def rstrip
  chars(@wrapped_string.gsub(Unicode::TRAILERS_PAT, ''))
end

def size
  Unicode.u_unpack(@wrapped_string).size
end

def slice(*args)
  if args.size > 2
    raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" # Do as if we were native
  elsif (args.size == 2 && !(args.first.is_a?(Numeric) || args.first.is_a?(Regexp)))
    raise TypeError, "cannot convert #{args.first.class} into Integer" # Do as if we were native
  elsif (args.size == 2 && !args[1].is_a?(Numeric))
    raise TypeError, "cannot convert #{args[1].class} into Integer" # Do as if we were native
  elsif args[0].kind_of? Range
    cps = Unicode.u_unpack(@wrapped_string).slice(*args)
    result = cps.nil? ? nil : cps.pack('U*')
  elsif args[0].kind_of? Regexp
    result = @wrapped_string.slice(*args)
  elsif args.size == 1 && args[0].kind_of?(Numeric)
    character = Unicode.u_unpack(@wrapped_string)[args[0]]
    result = character && [character].pack('U')
  else
    cps = Unicode.u_unpack(@wrapped_string).slice(*args)
    result = cps && cps.pack('U*')
  end
  result && chars(result)
end

def split(*args)
  @wrapped_string.split(*args).map { |i| i.mb_chars }
end

def strip
  rstrip.lstrip
end

def tidy_bytes(force = false)
  chars(Unicode.tidy_bytes(@wrapped_string, force))
end

def titleize
  chars(downcase.to_s.gsub(/\b('?\S)/u) { Unicode.apply_mapping $1, :uppercase_mapping })
end

def translate_offset(byte_offset) #:nodoc:
  return nil if byte_offset.nil?
  return 0   if @wrapped_string == ''
  if @wrapped_string.respond_to?(:force_encoding)
    @wrapped_string = @wrapped_string.dup.force_encoding(Encoding::ASCII_8BIT)
  end
  begin
    @wrapped_string[0...byte_offset].unpack('U*').length
  rescue ArgumentError
    byte_offset -= 1
    retry
  end
end

def upcase
  chars(Unicode.apply_mapping(@wrapped_string, :uppercase_mapping))
end