text: # Licensed to the Apache Software Foundation (ASF) under one
  # or more contributor license agreements.  See the NOTICE file
  # distributed with this work for additional information
  # regarding copyright ownership.  The ASF licenses this file
  # to you under the Apache License, Version 2.0 (the
  # "License"); you may not use this file except in compliance
  # with the License.  You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  import binascii
  import calendar
  import datetime
  import math
  import os
  import re
  import sys
  import six
  import platform
  import wcwidth
  
  from collections import defaultdict
  from displaying import colorme, get_str, FormattedValue, DEFAULT_VALUE_COLORS, NO_COLOR_MAP
  from cassandra.cqltypes import EMPTY
  from cassandra.util import datetime_from_timestamp
  from util import UTC
  
  is_win = platform.system() == 'Windows'
  
  unicode_controlchars_re = re.compile(r'[\x00-\x31\x7f-\xa0]')
  controlchars_re = re.compile(r'[\x00-\x31\x7f-\xff]')
  
  
  def _show_control_chars(match):
      txt = repr(match.group(0))
      if txt.startswith('u'):
          txt = txt[2:-1]
      else:
          txt = txt[1:-1]
      return txt
  
  
  bits_to_turn_red_re = re.compile(r'\\([^uUx]|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|U[0-9a-fA-F]{8})')
  
  
  def _make_turn_bits_red_f(color1, color2):
      def _turn_bits_red(match):
          txt = match.group(0)
          if txt == '\\\\':
              return '\\'
          return color1 + txt + color2
      return _turn_bits_red
  
  
  default_null_placeholder = 'null'
  default_float_precision = 3
  default_colormap = DEFAULT_VALUE_COLORS
  empty_colormap = defaultdict(lambda: '')
  
  
  def format_by_type(val, cqltype, encoding, colormap=None, addcolor=False,
                     nullval=None, date_time_format=None, float_precision=None,
                     decimal_sep=None, thousands_sep=None, boolean_styles=None):
      if nullval is None:
          nullval = default_null_placeholder
      if val is None:
          return colorme(nullval, colormap, 'error')
      if addcolor is False:
          colormap = empty_colormap
      elif colormap is None:
          colormap = default_colormap
      if date_time_format is None:
          date_time_format = DateTimeFormat()
      if float_precision is None:
          float_precision = default_float_precision
      return format_value(val, cqltype=cqltype, encoding=encoding, colormap=colormap,
                          date_time_format=date_time_format, float_precision=float_precision,
                          nullval=nullval, decimal_sep=decimal_sep, thousands_sep=thousands_sep,
                          boolean_styles=boolean_styles)
  
  
  def color_text(bval, colormap, displaywidth=None):
      # note that here, we render natural backslashes as just backslashes,
      # in the same color as surrounding text, when using color. When not
      # using color, we need to double up the backslashes so it's not
      # ambiguous. This introduces the unique difficulty of having different
      # display widths for the colored and non-colored versions. To avoid
      # adding the smarts to handle that in to FormattedValue, we just
      # make an explicit check to see if a null colormap is being used or
      # not.
      if displaywidth is None:
          displaywidth = len(bval)
      tbr = _make_turn_bits_red_f(colormap['blob'], colormap['text'])
      coloredval = colormap['text'] + bits_to_turn_red_re.sub(tbr, bval) + colormap['reset']
      if colormap['text']:
          displaywidth -= bval.count(r'\\')
      return FormattedValue(bval, coloredval, displaywidth)
  
  
  DEFAULT_NANOTIME_FORMAT = '%H:%M:%S.%N'
  DEFAULT_DATE_FORMAT = '%Y-%m-%d'
  
  DEFAULT_TIMESTAMP_FORMAT = os.environ.get('CQLSH_DEFAULT_TIMESTAMP_FORMAT', '')
  if not DEFAULT_TIMESTAMP_FORMAT:
      DEFAULT_TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S.%f%z'
  
  
  class DateTimeFormat:
  
      def __init__(self, timestamp_format=DEFAULT_TIMESTAMP_FORMAT, date_format=DEFAULT_DATE_FORMAT,
                   nanotime_format=DEFAULT_NANOTIME_FORMAT, timezone=None, milliseconds_only=False):
          self.timestamp_format = timestamp_format
          self.date_format = date_format
          self.nanotime_format = nanotime_format
          self.timezone = timezone
          self.milliseconds_only = milliseconds_only  # the microseconds part, .NNNNNN, wil be rounded to .NNN
  
  
  class CqlType(object):
      """
      A class for converting a string into a cql type name that can match a formatter
      and a list of its sub-types, if any.
      """
      pattern = re.compile('^([^<]*)<(.*)>$')  # *<*>
  
      def __init__(self, typestring, ksmeta=None):
          self.type_name, self.sub_types, self.formatter = self.parse(typestring, ksmeta)
  
      def __str__(self):
          return "%s%s" % (self.type_name, self.sub_types or '')
  
      __repr__ = __str__
  
      def get_n_sub_types(self, num):
          """
          Return the sub-types if the requested number matches the length of the sub-types (tuples)
          or the first sub-type times the number requested if the length of the sub-types is one (list, set),
          otherwise raise an exception
          """
          if len(self.sub_types) == num:
              return self.sub_types
          elif len(self.sub_types) == 1:
              return [self.sub_types[0]] * num
          else:
              raise Exception("Unexpected number of subtypes %d - %s" % (num, self.sub_types))
  
      def parse(self, typestring, ksmeta):
          """
          Parse the typestring by looking at this pattern: *<*>. If there is no match then the type
          is either a simple type or a user type, otherwise it must be a composite type
          for which we need to look-up the sub-types. For user types the sub types can be extracted
          from the keyspace metadata.
          """
          while True:
              m = self.pattern.match(typestring)
              if not m:  # no match, either a simple or a user type
                  name = typestring
                  if ksmeta and name in ksmeta.user_types:  # a user type, look at ks meta for sub types
                      sub_types = [CqlType(t, ksmeta) for t in ksmeta.user_types[name].field_types]
                      return name, sub_types, format_value_utype
                  else:
                      return name, [], self._get_formatter(name)
              else:
                  if m.group(1) == 'frozen':  # ignore frozen<>
                      typestring = m.group(2)
                      continue
  
                  name = m.group(1)  # a composite type, parse sub types
                  return name, self.parse_sub_types(m.group(2), ksmeta), self._get_formatter(name)
  
      @staticmethod
      def _get_formatter(name):
          return _formatters.get(name.lower())
  
      @staticmethod
      def parse_sub_types(val, ksmeta):
          """
          Split val into sub-strings separated by commas but only if not within a <> pair
          Return a list of CqlType instances where each instance is initialized with the sub-strings
          that were found.
          """
          last = 0
          level = 0
          ret = []
          for i, c in enumerate(val):
              if c == '<':
                  level += 1
              elif c == '>':
                  level -= 1
              elif c == ',' and level == 0:
                  ret.append(val[last:i].strip())
                  last = i + 1
  
          if last < len(val) - 1:
              ret.append(val[last:].strip())
  
          return [CqlType(r, ksmeta) for r in ret]
  
  
  def format_value_default(val, colormap, **_):
      val = str(val)
      escapedval = val.replace('\\', '\\\\')
      bval = controlchars_re.sub(_show_control_chars, escapedval)
      return bval if colormap is NO_COLOR_MAP else color_text(bval, colormap)
  
  
  # Mapping cql type base names ("int", "map", etc) to formatter functions,
  # making format_value a generic function
  _formatters = {}
  
  
  def format_value(val, cqltype, **kwargs):
      if val == EMPTY:
          return format_value_default('', **kwargs)
  
      formatter = get_formatter(val, cqltype)
      return formatter(val, cqltype=cqltype, **kwargs)
  
  
  def get_formatter(val, cqltype):
      if cqltype and cqltype.formatter:
          return cqltype.formatter
  
      return _formatters.get(type(val).__name__.lower(), format_value_default)
  
  
  def formatter_for(typname):
      def registrator(f):
          _formatters[typname.lower()] = f
          return f
      return registrator
  
  class BlobType(object):
      def __init__(self, val):
          self.val = val
  
      def __str__(self):
          return str(self.val)
  
  @formatter_for('BlobType')
  def format_value_blob(val, colormap, **_):
      bval = '0x' + binascii.hexlify(val)
      return colorme(bval, colormap, 'blob')
  
  
  formatter_for('bytearray')(format_value_blob)
  formatter_for('buffer')(format_value_blob)
  formatter_for('blob')(format_value_blob)
  
  
  def format_python_formatted_type(val, colormap, color, quote=False):
      bval = str(val)
      if quote:
          bval = "'%s'" % bval
      return colorme(bval, colormap, color)
  
  
  @formatter_for('Decimal')
  def format_value_decimal(val, float_precision, colormap, decimal_sep=None, thousands_sep=None, **_):
      if (decimal_sep and decimal_sep != '.') or thousands_sep:
          return format_floating_point_type(val, colormap, float_precision, decimal_sep, thousands_sep)
      return format_python_formatted_type(val, colormap, 'decimal')
  
  
  @formatter_for('UUID')
  def format_value_uuid(val, colormap, **_):
      return format_python_formatted_type(val, colormap, 'uuid')
  
  
  formatter_for('timeuuid')(format_value_uuid)
  
  
  @formatter_for('inet')
  def formatter_value_inet(val, colormap, quote=False, **_):
      return format_python_formatted_type(val, colormap, 'inet', quote=quote)
  
  
  @formatter_for('bool')
  def format_value_boolean(val, colormap, boolean_styles=None, **_):
      if boolean_styles:
          val = boolean_styles[0] if val else boolean_styles[1]
      return format_python_formatted_type(val, colormap, 'boolean')
  
  
  formatter_for('boolean')(format_value_boolean)
  
  
  def format_floating_point_type(val, colormap, float_precision, decimal_sep=None, thousands_sep=None, **_):
      if math.isnan(val):
          bval = 'NaN'
      elif math.isinf(val):
          bval = 'Infinity' if val > 0 else '-Infinity'
      else:
          if thousands_sep:
              dpart, ipart = math.modf(val)
              bval = format_integer_with_thousands_sep(ipart, thousands_sep)
              dpart_str = ('%.*f' % (float_precision, math.fabs(dpart)))[2:].rstrip('0')
              if dpart_str:
                  bval += '%s%s' % ('.' if not decimal_sep else decimal_sep, dpart_str)
          else:
              exponent = int(math.log10(abs(val))) if abs(val) > sys.float_info.epsilon else -sys.maxsize - 1
              if -4 <= exponent < float_precision:
                  # when this is true %g will not use scientific notation,
                  # increasing precision should not change this decision
                  # so we increase the precision to take into account the
                  # digits to the left of the decimal point
                  float_precision = float_precision + exponent + 1
              bval = '%.*g' % (float_precision, val)
              if decimal_sep:
                  bval = bval.replace('.', decimal_sep)
  
      return colorme(bval, colormap, 'float')
  
  
  formatter_for('float')(format_floating_point_type)
  formatter_for('double')(format_floating_point_type)
  
  
  def format_integer_type(val, colormap, thousands_sep=None, **_):
      # base-10 only for now; support others?
      bval = format_integer_with_thousands_sep(val, thousands_sep) if thousands_sep else str(val)
      return colorme(bval, colormap, 'int')
  
  
  # We can get rid of this in cassandra-2.2
  if sys.version_info >= (2, 7):
      def format_integer_with_thousands_sep(val, thousands_sep=','):
          return "{:,.0f}".format(val).replace(',', thousands_sep)
  else:
      def format_integer_with_thousands_sep(val, thousands_sep=','):
          if val < 0:
              return '-' + format_integer_with_thousands_sep(-val, thousands_sep)
          result = ''
          while val >= 1000:
              val, r = divmod(val, 1000)
              result = "%s%03d%s" % (thousands_sep, r, result)
          return "%d%s" % (val, result)
  
  formatter_for('long')(format_integer_type)
  formatter_for('int')(format_integer_type)
  formatter_for('bigint')(format_integer_type)
  formatter_for('varint')(format_integer_type)
  formatter_for('duration')(format_integer_type)
  
  
  @formatter_for('datetime')
  def format_value_timestamp(val, colormap, date_time_format, quote=False, **_):
      if isinstance(val, datetime.datetime):
          bval = strftime(date_time_format.timestamp_format,
                          calendar.timegm(val.utctimetuple()),
                          microseconds=val.microsecond,
                          timezone=date_time_format.timezone)
          if date_time_format.milliseconds_only:
              bval = round_microseconds(bval)
      else:
          bval = str(val)
  
      if quote:
          bval = "'%s'" % bval
      return colorme(bval, colormap, 'timestamp')
  
  
  formatter_for('timestamp')(format_value_timestamp)
  
  
  def strftime(time_format, seconds, microseconds=0, timezone=None):
      ret_dt = datetime_from_timestamp(seconds) + datetime.timedelta(microseconds=microseconds)
      ret_dt = ret_dt.replace(tzinfo=UTC())
      if timezone:
          ret_dt = ret_dt.astimezone(timezone)
      try:
          return ret_dt.strftime(time_format)
      except ValueError:
          # CASSANDRA-13185: if the date cannot be formatted as a string, return a string with the milliseconds
          # since the epoch. cqlsh does the exact same thing for values below datetime.MINYEAR (1) or above
          # datetime.MAXYEAR (9999). Some versions of strftime() also have problems for dates between MIN_YEAR and 1900.
          # cqlsh COPY assumes milliseconds from the epoch if it fails to parse a datetime string, and so it is
          # able to correctly import timestamps exported as milliseconds since the epoch.
          return '%d' % (seconds * 1000.0)
  
  
  microseconds_regex = re.compile("(.*)(?:\.(\d{1,6}))(.*)")
  
  
  def round_microseconds(val):
      """
      For COPY TO, we need to round microsecond to milliseconds because server side
      TimestampSerializer.dateStringPatterns only parses milliseconds. If we keep microseconds,
      users may try to import with COPY FROM a file generated with COPY TO and have problems if
      prepared statements are disabled, see CASSANDRA-11631.
      """
      m = microseconds_regex.match(val)
      if not m:
          return val
  
      milliseconds = int(m.group(2)) * pow(10, 3 - len(m.group(2)))
      return '%s.%03d%s' % (m.group(1), milliseconds, '' if not m.group(3) else m.group(3))
  
  
  @formatter_for('Date')
  def format_value_date(val, colormap, **_):
      return format_python_formatted_type(val, colormap, 'date')
  
  
  @formatter_for('Time')
  def format_value_time(val, colormap, **_):
      return format_python_formatted_type(val, colormap, 'time')
  
  
  @formatter_for('Duration')
  def format_value_duration(val, colormap, **_):
      return format_python_formatted_type(duration_as_str(val.months, val.days, val.nanoseconds), colormap, 'duration')
  
  
  def duration_as_str(months, days, nanoseconds):
      builder = list()
      if months < 0 or days < 0 or nanoseconds < 0:
          builder.append('-')
  
      remainder = append(builder, abs(months), MONTHS_PER_YEAR, "y")
      append(builder, remainder, 1, "mo")
      append(builder, abs(days), 1, "d")
  
      if nanoseconds != 0:
          remainder = append(builder, abs(nanoseconds), NANOS_PER_HOUR, "h")
          remainder = append(builder, remainder, NANOS_PER_MINUTE, "m")
          remainder = append(builder, remainder, NANOS_PER_SECOND, "s")
          remainder = append(builder, remainder, NANOS_PER_MILLI, "ms")
          remainder = append(builder, remainder, NANOS_PER_MICRO, "us")
          append(builder, remainder, 1, "ns")
  
      return ''.join(builder)
  
  
  def append(builder, dividend, divisor, unit):
      if dividend == 0 or dividend < divisor:
          return dividend
  
      builder.append(str(dividend / divisor))
      builder.append(unit)
      return dividend % divisor
  
  
  def decode_vint(buf):
      return decode_zig_zag_64(decode_unsigned_vint(buf))
  
  
  def decode_unsigned_vint(buf):
      """
      Cassandra vints are encoded differently than the varints used in protocol buffer.
      The Cassandra vints are encoded with the most significant group first. The most significant byte will contains
      the information about how many extra bytes need to be read as well as the most significant bits of the integer.
      The number extra bytes to read is encoded as 1 bits on the left side.
      For example, if we need to read 3 more bytes the first byte will start with 1110.
      """
  
      first_byte = buf.next()
      if (first_byte >> 7) == 0:
          return first_byte
  
      size = number_of_extra_bytes_to_read(first_byte)
      retval = first_byte & (0xff >> size)
      for i in range(size):
          b = buf.next()
          retval <<= 8
          retval |= b & 0xff
  
      return retval
  
  
  def number_of_extra_bytes_to_read(b):
      return 8 - (~b & 0xff).bit_length()
  
  
  def decode_zig_zag_64(n):
      return (n >> 1) ^ -(n & 1)
  
  
  @formatter_for('str')
  def format_value_text(val, encoding, colormap, quote=False, **_):
      escapedval = val.replace(u'\\', u'\\\\')
      if quote:
          escapedval = escapedval.replace("'", "''")
      escapedval = unicode_controlchars_re.sub(_show_control_chars, escapedval)
      bval = escapedval.encode(encoding, 'backslashreplace')
      if quote:
          bval = "'%s'" % bval
  
      return bval if colormap is NO_COLOR_MAP else color_text(bval, colormap, wcwidth.wcswidth(bval.decode(encoding)))
  
  
  # name alias
  formatter_for('unicode')(format_value_text)
  formatter_for('text')(format_value_text)
  formatter_for('ascii')(format_value_text)
  
  
  def format_simple_collection(val, cqltype, lbracket, rbracket, encoding,
                               colormap, date_time_format, float_precision, nullval,
                               decimal_sep, thousands_sep, boolean_styles):
      subs = [format_value(sval, cqltype=stype, encoding=encoding, colormap=colormap,
                           date_time_format=date_time_format, float_precision=float_precision,
                           nullval=nullval, quote=True, decimal_sep=decimal_sep,
                           thousands_sep=thousands_sep, boolean_styles=boolean_styles)
              for sval, stype in zip(val, cqltype.get_n_sub_types(len(val)))]
      bval = lbracket + ', '.join(get_str(sval) for sval in subs) + rbracket
      if colormap is NO_COLOR_MAP:
          return bval
  
      lb, sep, rb = [colormap['collection'] + s + colormap['reset']
                     for s in (lbracket, ', ', rbracket)]
      coloredval = lb + sep.join(sval.coloredval for sval in subs) + rb
      displaywidth = 2 * len(subs) + sum(sval.displaywidth for sval in subs)
      return FormattedValue(bval, coloredval, displaywidth)
  
  
  @formatter_for('list')
  def format_value_list(val, cqltype, encoding, colormap, date_time_format, float_precision, nullval,
                        decimal_sep, thousands_sep, boolean_styles, **_):
      return format_simple_collection(val, cqltype, '[', ']', encoding, colormap,
                                      date_time_format, float_precision, nullval,
                                      decimal_sep, thousands_sep, boolean_styles)
  
  
  @formatter_for('tuple')
  def format_value_tuple(val, cqltype, encoding, colormap, date_time_format, float_precision, nullval,
                         decimal_sep, thousands_sep, boolean_styles, **_):
      return format_simple_collection(val, cqltype, '(', ')', encoding, colormap,
                                      date_time_format, float_precision, nullval,
                                      decimal_sep, thousands_sep, boolean_styles)
  
  
  @formatter_for('set')
  def format_value_set(val, cqltype, encoding, colormap, date_time_format, float_precision, nullval,
                       decimal_sep, thousands_sep, boolean_styles, **_):
      return format_simple_collection(sorted(val), cqltype, '{', '}', encoding, colormap,
                                      date_time_format, float_precision, nullval,
                                      decimal_sep, thousands_sep, boolean_styles)
  
  
  formatter_for('frozenset')(format_value_set)
  formatter_for('sortedset')(format_value_set)
  formatter_for('SortedSet')(format_value_set)
  
  
  @formatter_for('dict')
  def format_value_map(val, cqltype, encoding, colormap, date_time_format, float_precision, nullval,
                       decimal_sep, thousands_sep, boolean_styles, **_):
      def subformat(v, t):
          return format_value(v, cqltype=t, encoding=encoding, colormap=colormap,
                              date_time_format=date_time_format, float_precision=float_precision,
                              nullval=nullval, quote=True, decimal_sep=decimal_sep,
                              thousands_sep=thousands_sep, boolean_styles=boolean_styles)
  
      subs = [(subformat(k, cqltype.sub_types[0]), subformat(v, cqltype.sub_types[1])) for (k, v) in sorted(val.items())]
      bval = '{' + ', '.join(get_str(k) + ': ' + get_str(v) for (k, v) in subs) + '}'
      if colormap is NO_COLOR_MAP:
          return bval
  
      lb, comma, colon, rb = [colormap['collection'] + s + colormap['reset']
                              for s in ('{', ', ', ': ', '}')]
      coloredval = lb \
          + comma.join(k.coloredval + colon + v.coloredval for (k, v) in subs) \
          + rb
      displaywidth = 4 * len(subs) + sum(k.displaywidth + v.displaywidth for (k, v) in subs)
      return FormattedValue(bval, coloredval, displaywidth)
  
  
  formatter_for('OrderedDict')(format_value_map)
  formatter_for('OrderedMap')(format_value_map)
  formatter_for('OrderedMapSerializedKey')(format_value_map)
  formatter_for('map')(format_value_map)
  
  
  def format_value_utype(val, cqltype, encoding, colormap, date_time_format, float_precision, nullval,
                         decimal_sep, thousands_sep, boolean_styles, **_):
      def format_field_value(v, t):
          if v is None:
              return colorme(nullval, colormap, 'error')
          return format_value(v, cqltype=t, encoding=encoding, colormap=colormap,
                              date_time_format=date_time_format, float_precision=float_precision,
                              nullval=nullval, quote=True, decimal_sep=decimal_sep,
                              thousands_sep=thousands_sep, boolean_styles=boolean_styles)
  
      def format_field_name(name):
          return format_value_text(name, encoding=encoding, colormap=colormap, quote=False)
  
      subs = [(format_field_name(k), format_field_value(v, t)) for ((k, v), t) in zip(val._asdict().items(),
                                                                                      cqltype.sub_types)]
      bval = '{' + ', '.join(get_str(k) + ': ' + get_str(v) for (k, v) in subs) + '}'
      if colormap is NO_COLOR_MAP:
          return bval
  
      lb, comma, colon, rb = [colormap['collection'] + s + colormap['reset']
                              for s in ('{', ', ', ': ', '}')]
      coloredval = lb \
          + comma.join(k.coloredval + colon + v.coloredval for (k, v) in subs) \
          + rb
      displaywidth = 4 * len(subs) + sum(k.displaywidth + v.displaywidth for (k, v) in subs)
      return FormattedValue(bval, coloredval, displaywidth)
  
  
  NANOS_PER_MICRO = 1000
  NANOS_PER_MILLI = 1000 * NANOS_PER_MICRO
  NANOS_PER_SECOND = 1000 * NANOS_PER_MILLI
  NANOS_PER_MINUTE = 60 * NANOS_PER_SECOND
  NANOS_PER_HOUR = 60 * NANOS_PER_MINUTE
  MONTHS_PER_YEAR = 12
  