#!/usr/bin/env python
import argparse
import bisect
import copy
import json
import math
import numbers
import os
import struct
import sys
import uuid
import zlib
from ctypes import create_string_buffer
sys.path.append(os.path.join(os.getcwd(), 'pactool'))
from sfs_module import SFSImageHandler
import traceback
from functools import cmp_to_key

def error(str):
  callstack = traceback.format_exc()
  sys.stderr.write('\033[1;31m%s\033[0m\n' %str)
  sys.stderr.write('\033[1;31m%s\033[0m\n' %callstack)
  sys.exit(1)

# Python 2.6 required for modern exception syntax
if sys.hexversion < 0x02060000:
  error("Python 2.6 or newer is required.")

# Keywords used in JSON files.
JSON_KEYWORD_SETTINGS = 'settings'
JSON_KEYWORD_SETTINGS_AB_SUFFIXES = 'ab_suffixes'
JSON_KEYWORD_SETTINGS_DISK_SIZE = 'disk_size'
JSON_KEYWORD_SETTINGS_DISK_ALIGNMENT = 'disk_alignment'
JSON_KEYWORD_SETTINGS_DISK_GUID = 'disk_guid'
JSON_KEYWORD_SETTINGS_PARTITIONS_OFFSET_BEGIN = 'partitions_offset_begin'
JSON_KEYWORD_PARTITIONS = 'partitions'
JSON_KEYWORD_PARTITIONS_LABEL = 'label'
JSON_KEYWORD_PARTITIONS_OFFSET = 'offset'
JSON_KEYWORD_PARTITIONS_SIZE = 'size'
JSON_KEYWORD_PARTITIONS_GROW = 'grow'
JSON_KEYWORD_PARTITIONS_GUID = 'guid'
JSON_KEYWORD_PARTITIONS_TYPE_GUID = 'type_guid'
JSON_KEYWORD_PARTITIONS_FLAGS = 'flags'
JSON_KEYWORD_PARTITIONS_PERSIST = 'persist'
JSON_KEYWORD_PARTITIONS_IGNORE = 'ignore'
JSON_KEYWORD_PARTITIONS_AB = 'ab'
JSON_KEYWORD_PARTITIONS_AB_EXPANDED = 'ab_expanded'
JSON_KEYWORD_PARTITIONS_POSITION = 'position'
JSON_KEYWORD_AUTO = 'auto'

SAFETY_PATITION_NAME = ["os", "dil", 'boot']
SAFETY_BAK_PATITION_NAME = ["os_bak", "dil_bak", 'boot_back']
SAFETY_THIRD_PATITION_NAME = ['boot_third']
SFS_IMG_MAX_SIZE = 128

# Possible values for the --type option of the query_partition
# sub-command.
QUERY_PARTITION_TYPES = ['size',
                         'offset',
                         'guid',
                         'type_guid',
                         'flags',
                         'persist']

PACKTOOL_VERSION_MAJOR = 1
PACKTOOL_VERSION_MINOR = 0

DISK_SECTOR_SIZE = 512

GPT_NUM_LBAS = 33

GPT_MIN_PART_NUM = 1
GPT_MAX_PART_NUM = 128

PACKET_MAGIC = 0x5041434B
PACKET_STRUCT_VER = 0x0
PACKET_HEADER_SIZE = 0x400  # 1K
PACKET_FILETS_SIZE = 0x4000  # 16K = 128 * 128
PACKET_INFO_SIZE = PACKET_HEADER_SIZE + PACKET_FILETS_SIZE

E_PACK_FIRST_DA_FILE = 0
E_PACK_MID_DA_FILE = 1
E_PACK_DLOADER_FILE = 2
E_PACK_SPL_FILE = 3
E_PACK_SFS_FILE = 4
E_PACK_GPT_FILE = 5
E_PACK_IMG_FILE = 6
E_PACK_PAC_FILE = 7

E_PACK_FBL_FILE = 8  # boot0
E_PACK_SBL_FILE = 9  # boot1
E_PACK_TBL_FILE = 10  # boot2
E_PACK_NFS_FILE = 11  # NFS
E_PACK_RFD_FILE = 12  # RFD

NEW_PRELOAD_NAMES = ["boot0", "boot1", "boot2", "nfs", "rfd"]
PRELOAD_NAMES = ["spl", "sfs"] + NEW_PRELOAD_NAMES
PRELOAD_TYPES = [E_PACK_SPL_FILE, E_PACK_SFS_FILE, E_PACK_FBL_FILE, E_PACK_SBL_FILE, E_PACK_TBL_FILE,
                 E_PACK_NFS_FILE, E_PACK_RFD_FILE]
STR_PACK_TYPE = ["FDA", "OSPIDA", "DLOADER", "SPL", "SFS", "GPT", "IMG", "PAC", "BOOT0", "BOOT1", "BOOT2", "NFS", "RFD"]

DA_ID_LIST = ["FDA", "OPSIDA", "DLOADER"]

MAX_BUFFER_SIZE = 0x4000000 # 64M

KNOWN_TYPE_GUIDS = {
    'brillo_boot': 'bb499290-b57e-49f6-bf41-190386693794',
    'brillo_bootloader': '4892aeb3-a45f-4c5f-875f-da3303c0795c',
    'brillo_system': '0f2778c4-5cc1-4300-8670-6c88b7e57ed6',
    'brillo_odm': 'e99d84d7-2c1b-44cf-8c58-effae2dc2558',
    'brillo_oem': 'aa3434b2-ddc3-4065-8b1a-18e99ea15cb7',
    'brillo_userdata': '0bb7e6ed-4424-49c0-9372-7fbab465ab4c',
    'brillo_misc': '6b2378b0-0fbc-4aa9-a4f6-4d6e17281c47',
    'brillo_vbmeta': 'b598858a-5fe3-418e-b8c4-824b41f4adfc',
    'brillo_vendor_specific': '314f99d5-b2bf-4883-8d03-e2f2ce507d6a',
    'linux_fs': '0fc63daf-8483-4772-8e79-3d69d8477de4',
    'ms_basic_data': 'ebd0a0a2-b9e5-4433-87c0-68b6b72699c7',
    'efi_system': 'c12a7328-f81f-11d2-ba4b-00a0c93ec93b',
    'secondary_partition_identifier': '7d06a189-1fef-4d89-8940-e8c2a6832ecf'
}


def get_file_extension(path):
  return os.path.splitext(path)[1]

def RoundToMultiple(number, size, round_down=False):
  """Rounds a number up (or down) to nearest multiple of another number.

  Args:
    number: The number to round up.
    size: The multiple to round up to.
    round_down: If True, the number will be rounded down.

  Returns:
    If |number| is a multiple of |size|, returns |number|, otherwise
    returns |number| + |size| - |remainder| (if |round_down| is False) or
    |number| - |remainder| (if |round_down| is True). Always returns
    an integer.
  """
  remainder = number % size
  if remainder == 0:
    return int(number)
  if round_down:
    return int(number - remainder)
  return int(number + size - remainder)


def ParseNumber(arg):
  """Number parser.

  If |arg| is an integer, that value is returned. Otherwise int(arg, 0)
  is returned.

  This function is suitable for use in the |type| parameter of
  |ArgumentParser|'s add_argument() function. An improvement to just
  using type=int is that this function supports numbers in other
  bases, e.g. "0x1234".

  Arguments:
    arg: Argument (int or string) to parse.

  Returns:
    The parsed value, as an integer.

  Raises:
    ValueError: If the argument could not be parsed.
  """
  if isinstance(arg, numbers.Integral):
    return arg
  return int(arg, 0)


def ParseGuid(arg):
  """Parser for RFC 4122 GUIDs.

  Arguments:
    arg: The argument, as a string.

  Returns:
    UUID in hyphenated format.

  Raises:
    ValueError: If the given string cannot be parsed.
  """
  return str(uuid.UUID(arg))


def ParseSize(arg):
  """Parser for size strings with decimal and binary unit support.

  This supports both integers and strings.

  Arguments:
    arg: The string to parse.

  Returns:
    The parsed size in bytes as an integer.

  Raises:
    ValueError: If the given string cannot be parsed.
  """
  if isinstance(arg, numbers.Integral):
    return arg

  ws_index = arg.find(' ')
  if ws_index != -1:
    num = float(arg[0:ws_index])
    factor = 1
    if arg.endswith('KiB'):
      factor = 1024
    elif arg.endswith('MiB'):
      factor = 1024*1024
    elif arg.endswith('GiB'):
      factor = 1024*1024*1024
    elif arg.endswith('TiB'):
      factor = 1024*1024*1024*1024
    elif arg.endswith('PiB'):
      factor = 1024*1024*1024*1024*1024
    elif arg.endswith('kB'):
      factor = 1000
    elif arg.endswith('MB'):
      factor = 1000*1000
    elif arg.endswith('GB'):
      factor = 1000*1000*1000
    elif arg.endswith('TB'):
      factor = 1000*1000*1000*1000
    elif arg.endswith('PB'):
      factor = 1000*1000*1000*1000*1000
    else:
      raise ValueError('Cannot parse string "{}"'.format(arg))
    value = num*factor
    # If the resulting value isn't an integer, round up.
    if not value.is_integer():
      value = int(math.ceil(value))
  else:
    value = int(arg, 0)
  return int(value)


class ImageHandler(object):
  """Abstraction for image I/O with support for Android sparse images.

  This class provides an interface for working with image files that
  may be using the Android Sparse Image format. When an instance is
  constructed, we test whether it's an Android sparse file. If so,
  operations will be on the sparse file by interpreting the sparse
  format, otherwise they will be directly on the file. Either way the
  operations do the same.

  For reading, this interface mimics a file object - it has seek(),
  tell(), and read() methods. For writing, only truncation
  (truncate()) and appending is supported (append_raw(),
  append_fill(), and append_dont_care()). Additionally, data can only
  be written in units of the block size.

  Attributes:
    is_sparse: Whether the file being operated on is sparse.
    block_size: The block size, typically 4096.
    image_size: The size of the unsparsified file.

  """
  # See system/core/libsparse/sparse_format.h for details.
  MAGIC = 0xed26ff3a
  HEADER_FORMAT = '<I4H4I'

  # These are formats and offset of just the |total_chunks| and
  # |total_blocks| fields.
  NUM_CHUNKS_AND_BLOCKS_FORMAT = '<II'
  NUM_CHUNKS_AND_BLOCKS_OFFSET = 16

  def __init__(self, image_filename):
    """Initializes an image handler.

    Arguments:
      image_filename: The name of the file to operate on.

    Raises:
      ValueError: If data in the file is invalid.
    """
    self._image_filename = image_filename
    self._read_header()

  def _read_header(self):
    """Initializes internal data structures used for reading file.

    This may be called multiple times and is typically called after
    modifying the file (e.g. appending, truncation).

    Raises:
      ValueError: If data in the file is invalid.
    """
    self.is_sparse = False
    self.block_size = 4096
    self._file_pos = 0
    try:
      self._image = open(self._image_filename, 'rb')
    except IOError as e:
      error(e)

    self._image.seek(0, os.SEEK_END)
    self.image_size = self._image.tell()
    self.raw_image_size = self.image_size

    self._image.seek(0, os.SEEK_SET)
    header_bin = self._image.read(struct.calcsize(self.HEADER_FORMAT))
    if len(header_bin) < struct.calcsize(self.HEADER_FORMAT):
      # Not a sparse image, our job here is done.
      return
    (magic, major_version, minor_version, file_hdr_sz, chunk_hdr_sz,
     block_size, self._num_total_blocks, self._num_total_chunks,
     _) = struct.unpack(self.HEADER_FORMAT, header_bin)

    self._image.seek(0, os.SEEK_SET)
    if magic == self.MAGIC:
        if not (major_version == 1 and minor_version == 0):
            raise ValueError('Encountered sparse image format version {}.{} but '
                             'only 1.0 is supported'.format(major_version,
                                                            minor_version))
        if file_hdr_sz != struct.calcsize(self.HEADER_FORMAT):
            raise ValueError('Unexpected file_hdr_sz value {}.'.
                             format(file_hdr_sz))

        self.raw_image_size = block_size * self._num_total_blocks
        self.is_sparse = True

  def seek(self, offset):
    """Sets the cursor position for reading from unsparsified file.

    Arguments:
      offset: Offset to seek to from the beginning of the file.
    """
    self._file_pos = offset

  def read(self, size):
    """Reads data from the unsparsified file.

    This method may return fewer than |size| bytes of data if the end
    of the file was encountered.

    The file cursor for reading is advanced by the number of bytes
    read.

    Arguments:
      size: Number of bytes to read.

    Returns:
      The data.

    """
    self._image.seek(self._file_pos)
    data = self._image.read(size)
    self._file_pos += len(data)
    return data

  def tell(self):
    """Returns the file cursor position for reading from unsparsified file.

    Returns:
      The file cursor position for reading.
    """
    return self._file_pos


class GuidGenerator(object):
  """An interface for obtaining strings that are GUIDs.

  To facilitate unit testing, this abstraction is used instead of the
  directly using the uuid module.
  """

  def dispense_guid(self, partition_number):
    """Dispenses a GUID.

    Arguments:
      partition_number: The partition number or 0 if requesting a GUID
                        for the whole disk.

    Returns:
      A RFC 4122 compliant GUID, as a string.
    """
    return str(uuid.uuid4())


class Partition(object):
  """Object representing a partition.

  Attributes:
    label: The partition label.
    offset: Offset of the partition on the disk, or None.
    size: Size of the partition or None if not specified.
    grow: True if partition has been requested to use all remaining space.
    guid: Instance GUID (RFC 4122 compliant) as a string or None or 'auto'
          if it should be automatically generated.
    type_guid: Type GUID (RFC 4122 compliant) as a string or a known type
               from the |KNOWN_TYPE_GUIDS| map.
    flags: GUID flags.
    persist: If true, sets bit 0 of flags indicating that this partition should
             not be deleted by the bootloader.
    ab: If True, the partition is an A/B partition.
    ab_expanded: If True, the A/B partitions have been generated.
    ignore: If True, the partition should not be included in the final output.
    position: The requested position of the partition or 0 if it doesn't matter.
  """

  def __init__(self):
    """Initializer method."""
    self.label = ''
    self.offset = None
    self.size = None
    self.grow = False
    self.guid = None
    self.type_guid = None
    self.flags = 0
    self.persist = False
    self.ab = False
    self.ab_expanded = False
    self.ignore = False
    self.position = 0

  def add_info(self, pobj):
    """Add information to partition.

    Arguments:
      pobj: A JSON object with information about the partition.
    """
    self.label = pobj[JSON_KEYWORD_PARTITIONS_LABEL]
    value = pobj.get(JSON_KEYWORD_PARTITIONS_OFFSET)
    if value is not None:
      self.offset = ParseSize(value)
    value = pobj.get(JSON_KEYWORD_PARTITIONS_SIZE)
    if value is not None:
      self.size = ParseSize(value)
    value = pobj.get(JSON_KEYWORD_PARTITIONS_GROW)
    if value is not None:
      self.grow = value
    value = pobj.get(JSON_KEYWORD_PARTITIONS_AB)
    if value is not None:
      self.ab = value
    value = pobj.get(JSON_KEYWORD_PARTITIONS_AB_EXPANDED)
    if value is not None:
      self.ab_expanded = value
    value = pobj.get(JSON_KEYWORD_PARTITIONS_GUID)
    if value is not None:
      self.guid = value
    value = pobj.get(JSON_KEYWORD_PARTITIONS_IGNORE)
    if value is not None:
      self.ignore = value
    value = pobj.get(JSON_KEYWORD_PARTITIONS_TYPE_GUID)
    if value is not None:
      self.type_guid = str.lower(str(value))
      if self.type_guid in KNOWN_TYPE_GUIDS:
        self.type_guid = KNOWN_TYPE_GUIDS[self.type_guid]
    value = pobj.get(JSON_KEYWORD_PARTITIONS_FLAGS)
    if value is not None:
      self.flags = ParseNumber(value)
    value = pobj.get(JSON_KEYWORD_PARTITIONS_PERSIST)
    if value is not None:
      self.persist = value
      if value:
        self.flags = self.flags | 0x1
    value = pobj.get(JSON_KEYWORD_PARTITIONS_POSITION)
    if value is not None:
      self.position = ParseNumber(value)

  def expand_guid(self, guid_generator, partition_number):
    """Assign instance GUID and type GUID if required.

    Arguments:
      guid_generator: A GuidGenerator object.
      partition_number: The partition number, starting from 1.
    """
    if not self.guid or self.guid == JSON_KEYWORD_AUTO:
      self.guid = guid_generator.dispense_guid(partition_number)
    if not self.type_guid:
      self.type_guid = KNOWN_TYPE_GUIDS['brillo_vendor_specific']

  def validate(self):
    """Sanity checks data in object."""

    try:
      _ = uuid.UUID(str(self.guid))
    except ValueError:
      raise ValueError('The string "{}" is not a valid GPT instance GUID on '
                       'partition with label "{}".'.format(
                           str(self.guid), self.label))

    try:
      _ = uuid.UUID(str(self.type_guid))
    except ValueError:
      raise ValueError('The string "{}" is not a valid GPT type GUID on '
                       'partition with label "{}".'.format(
                           str(self.type_guid), self.label))

    if not self.size:
      if not self.grow:
        raise ValueError('Size can only be unset if "grow" is True.')

  def cmp(self, other):
    """Comparison method."""
    self_position = self.position
    if self_position == 0:
      self_position = GPT_MAX_PART_NUM
    other_position = other.position
    if other_position == 0:
      other_position = GPT_MAX_PART_NUM
    return cmp(self_position, other_position)


class Settings(object):
  """An object for holding settings.

  Attributes:
    ab_suffixes: A list of A/B suffixes to use.
    disk_size: An integer with the disk size in bytes.
    partitions_offset_begin: An integer with the disk partitions
                             offset begin size in bytes.
    disk_alignment: The alignment to use for partitions.
    disk_guid: The GUID to use for the disk or None or 'auto' if
               automatically generated.
  """

  def __init__(self):
    """Initializer with defaults."""
    self.ab_suffixes = ['_a', '_b']
    self.disk_size = None
    self.partitions_offset_begin = 0
    self.disk_alignment = 4096
    self.disk_guid = JSON_KEYWORD_AUTO


class PackError(Exception):
  """Application-specific errors.

  These errors represent issues for which a stack-trace should not be
  presented.

  Attributes:
    message: Error message.
  """

  def __init__(self, message):
      self.message = message
      Exception.__init__(self, message)


class PackParsingError(PackError):
  """Represents an error with an input file.

  Attributes:
    message: Error message.
    filename: Name of the file that caused an error.
  """

  def __init__(self, filename, message):
    self.filename = filename
    PackError.__init__(self, message)


class Packet(object):
  """Business logic for bpttool command-line tool."""

  def _read_json(self, input_files, ab_collapse=True):
    """Parses a stack of JSON files into suitable data structures.

    The order of files matters as later files can modify partitions
    declared in earlier files.

    Arguments:
      input_files: An ordered list of open files.
      ab_collapse: If True, collapse A/B partitions.

    Returns:
      A tuple where the first element is a list of Partition objects
      and the second element is a Settings object.

    Raises:
      PackParsingError: If an input file has an error.
    """
    partitions = []
    settings = Settings()

    # Read all input file and merge partitions and settings.
    for f in input_files:
      try:
        obj = json.loads(f.read())
      except ValueError as e:
        # Unfortunately we can't easily get the line number where the
        # error occurred.
        raise PackParsingError(f.name, e.message)

      sobj = obj.get(JSON_KEYWORD_SETTINGS)
      if sobj:
        ab_suffixes = sobj.get(JSON_KEYWORD_SETTINGS_AB_SUFFIXES)
        if ab_suffixes:
          settings.ab_suffixes = ab_suffixes
        disk_size = sobj.get(JSON_KEYWORD_SETTINGS_DISK_SIZE)
        if disk_size:
          settings.disk_size = ParseSize(disk_size)
        partitions_offset_begin = sobj.get(
                JSON_KEYWORD_SETTINGS_PARTITIONS_OFFSET_BEGIN)
        if partitions_offset_begin:
          settings.partitions_offset_begin = ParseSize(partitions_offset_begin)
        disk_alignment = sobj.get(JSON_KEYWORD_SETTINGS_DISK_ALIGNMENT)
        if disk_alignment:
          settings.disk_alignment = ParseSize(disk_alignment)
        disk_guid = sobj.get(JSON_KEYWORD_SETTINGS_DISK_GUID)
        if disk_guid:
          settings.disk_guid = disk_guid

      pobjs = obj.get(JSON_KEYWORD_PARTITIONS)
      if pobjs:
        for pobj in pobjs:
          if ab_collapse and pobj.get(JSON_KEYWORD_PARTITIONS_AB_EXPANDED):
            # If we encounter an expanded partition, unexpand it. This
            # is to make it possible to use output-JSON (from this tool)
            # and stack it with an input-JSON file that e.g. specifies
            # size='256 GiB' for the 'system' partition.
            label = pobj[JSON_KEYWORD_PARTITIONS_LABEL]
            if label.endswith(settings.ab_suffixes[0]):
              # Modify first A/B copy so it doesn't have the trailing suffix.
              new_len = len(label) - len(settings.ab_suffixes[0])
              pobj[JSON_KEYWORD_PARTITIONS_LABEL] = label[0:new_len]
              pobj[JSON_KEYWORD_PARTITIONS_AB_EXPANDED] = False
              pobj[JSON_KEYWORD_PARTITIONS_GUID] = JSON_KEYWORD_AUTO
            else:
              # Skip other A/B copies.
              continue
          # Find or create a partition.
          p = None
          for candidate in partitions:
            if candidate.label == pobj[JSON_KEYWORD_PARTITIONS_LABEL]:
              p = candidate
              break
          if not p:
            p = Partition()
            partitions.append(p)
          p.add_info(pobj)

    return partitions, settings

  def _generate_json(self, partitions, settings):
    """Generate a string with JSON representing partitions and settings.

    Arguments:
      partitions: A list of Partition objects.
      settings: A Settings object.

    Returns:
      A JSON string.
    """
    suffixes_str = '['
    for n in range(0, len(settings.ab_suffixes)):
      if n != 0:
        suffixes_str += ', '
      suffixes_str += '"{}"'.format(settings.ab_suffixes[n])
    suffixes_str += ']'

    ret = ('{{\n'
           '  "' + JSON_KEYWORD_SETTINGS + '": {{\n'
           '    "' + JSON_KEYWORD_SETTINGS_AB_SUFFIXES + '": {},\n'
           '    "' + JSON_KEYWORD_SETTINGS_PARTITIONS_OFFSET_BEGIN + '": {},\n'
           '    "' + JSON_KEYWORD_SETTINGS_DISK_SIZE + '": {},\n'
           '    "' + JSON_KEYWORD_SETTINGS_DISK_ALIGNMENT + '": {},\n'
           '    "' + JSON_KEYWORD_SETTINGS_DISK_GUID + '": "{}"\n'
           '  }},\n'
           '  "' + JSON_KEYWORD_PARTITIONS + '": [\n').format(
               suffixes_str,
               settings.partitions_offset_begin,
               settings.disk_size,
               settings.disk_alignment,
               settings.disk_guid)

    for n in range(0, len(partitions)):
      p = partitions[n]
      ret += ('    {{\n'
              '      "' + JSON_KEYWORD_PARTITIONS_LABEL + '": "{}",\n'
              '      "' + JSON_KEYWORD_PARTITIONS_OFFSET + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_SIZE + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_GROW + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_GUID + '": "{}",\n'
              '      "' + JSON_KEYWORD_PARTITIONS_TYPE_GUID + '": "{}",\n'
              '      "' + JSON_KEYWORD_PARTITIONS_FLAGS + '": "{:#018x}",\n'
              '      "' + JSON_KEYWORD_PARTITIONS_PERSIST + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_IGNORE + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_AB + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_AB_EXPANDED + '": {},\n'
              '      "' + JSON_KEYWORD_PARTITIONS_POSITION + '": {}\n'
              '    }}{}\n').format(p.label,
                                   p.offset,
                                   p.size,
                                   'true' if p.grow else 'false',
                                   p.guid,
                                   p.type_guid,
                                   p.flags,
                                   'true' if p.persist else 'false',
                                   'true' if p.ignore else 'false',
                                   'true' if p.ab else 'false',
                                   'true' if p.ab_expanded else 'false',
                                   p.position,
                                   '' if n == len(partitions) - 1 else ',')
    ret += ('  ]\n'
            '}\n')
    return ret

  def _lba_to_chs(self, lba):
    """Converts LBA to CHS.

    Arguments:
      lba: The sector number to convert.

    Returns:
      An array containing the CHS encoded the way it's expected in a
      MBR partition table.
    """
    # See https://en.wikipedia.org/wiki/Cylinder-head-sector
    num_heads = 255
    num_sectors = 63
    # If LBA isn't going to fit in CHS, return maximum CHS values.
    max_lba = 255*num_heads*num_sectors
    if lba > max_lba:
      return [255, 255, 255]
    c = (int)(lba / (num_heads*num_sectors))
    h = (lba / num_sectors) % num_heads
    s = (int)(lba % num_sectors)
    return [(int)(h), (int)((((c>>8) & 0x03)<<6) | (s & 0x3f)), (int)(c & 0xff)]

  def _generate_protective_mbr(self, settings):
    """Generate Protective MBR.

    Arguments:
      settings: A Settings object.

    Returns:
      A string with the binary protective MBR (512 bytes).
    """
    # See https://en.wikipedia.org/wiki/Master_boot_record for MBR layout.
    #
    # The first partition starts at offset 446 (0x1be).
    lba_start = 1
    lba_end = (int)(settings.disk_size/DISK_SECTOR_SIZE - 1)
    start_chs = self._lba_to_chs(lba_start)
    end_chs = self._lba_to_chs(lba_end)

    pmbr = struct.pack('<BBB'      # Bootloader code
                       '443x'      # Padding to get to offset 446.
                       'B'         # Status.
                       'BBB'       # CHS start.
                       'B'         # Partition type.
                       'BBB'       # CHS end.
                       'I'         # LBA of partition start.
                       'I'         # Number of sectors in partition.
                       '48x'       # Padding to get to offset 510 (0x1fe).
                       'BB',       # Boot signature.
                       0xfa, 0xeb, 0xfe,  # cli ; jmp $ (x86)
                       0x00,
                       start_chs[0], start_chs[1], start_chs[2],
                       0xee,       # MBR Partition Type: GPT protective MBR.
                       end_chs[0], end_chs[1], end_chs[2],
                       1,          # LBA start
                       lba_end,
                       0x55, 0xaa)
    return pmbr

  def _generate_gpt(self, partitions, settings, primary=True):
    """Generate GUID Partition Table.

    Arguments:
      partitions: A list of Partition objects.
      settings: A Settings object.
      primary: True to generate primary GPT, False to generate secondary.

    Returns:
      A string with the binary GUID Partition Table (33*512 bytes).
    """
    # See https://en.wikipedia.org/wiki/Master_boot_record for MBR layout.
    #
    # The first partition starts at offset 446 (0x1be).

    disk_num_lbas = settings.disk_size/DISK_SECTOR_SIZE
    if primary:
      current_lba = 1
      other_lba = disk_num_lbas - 1
      partitions_lba = 2
    else:
      current_lba = disk_num_lbas - 1
      other_lba = 1
      partitions_lba = disk_num_lbas - GPT_NUM_LBAS
    first_usable_lba = GPT_NUM_LBAS + 1
    last_usable_lba = disk_num_lbas - GPT_NUM_LBAS - 1

    part_array = []
    part_data = create_string_buffer(128*128)
    offset = 0
    for p in partitions:
      type_uuid_byte = uuid.UUID(p.type_guid).bytes
      uuid_byte = uuid.UUID(p.guid).bytes
      struct.pack_into(
      '<16B'    # Partition type GUID.
      '16B'     # Partition instance GUID.
      'QQ'      # First and last LBA.
      'Q'       # Flags.
      '72s',    # Name (36 UTF-16LE code units).
      part_data,
      offset,
      type_uuid_byte[3],type_uuid_byte[2],type_uuid_byte[1],type_uuid_byte[0],
      type_uuid_byte[5],type_uuid_byte[4],
      type_uuid_byte[7],type_uuid_byte[6],
      type_uuid_byte[8],type_uuid_byte[9],type_uuid_byte[10],type_uuid_byte[11],
      type_uuid_byte[12],type_uuid_byte[13],type_uuid_byte[14],type_uuid_byte[15],
      uuid_byte[3],uuid_byte[2],uuid_byte[1],uuid_byte[0],
      uuid_byte[5],uuid_byte[4],
      uuid_byte[7],uuid_byte[6],
      uuid_byte[8],uuid_byte[9],uuid_byte[10],uuid_byte[11],
      uuid_byte[12],uuid_byte[13],uuid_byte[14],uuid_byte[15],
      int(p.offset/DISK_SECTOR_SIZE),
      int((p.offset + p.size)/DISK_SECTOR_SIZE - 1),
      int(p.flags),
      p.label.encode(encoding='utf-16le'))
      offset += 128
    partitions_crc32 = zlib.crc32( bytes(bytearray(part_data)) ) % (1<<32)

    header_crc32 = 0
    while True:
      uuid_byte = uuid.UUID(settings.disk_guid).bytes
      header = struct.pack(
          '<8s'    # Signature.
          '4B'     # Version.
          'I'      # Header size.
          'I'      # CRC32 (must be zero during calculation).
          'I'      # Reserved (must be zero).
          'QQ'     # Current and Other LBA.
          'QQ'     # First and last usable LBA.
          '16B'     # Disk GUID.
          'Q'      # Starting LBA of array of partitions.
          'I'      # Number of partitions.
          'I'      # Partition entry size, in bytes.
          'I'      # CRC32 of partition array
          '420x',  # Padding to get to 512 bytes.
          b'EFI PART',
          0x00, 0x00, 0x01, 0x00,
          92,
          int(header_crc32),
          0x00000000,
          int(current_lba), int(other_lba),
          int(first_usable_lba), int(last_usable_lba),
          uuid_byte[3],uuid_byte[2],uuid_byte[1],uuid_byte[0],
          uuid_byte[5],uuid_byte[4],
          uuid_byte[7],uuid_byte[6],
          uuid_byte[8],uuid_byte[9],uuid_byte[10],uuid_byte[11],
          uuid_byte[12],uuid_byte[13],uuid_byte[14],uuid_byte[15],
          int(partitions_lba),
          128,
          128,
          int(partitions_crc32))
      if not header_crc32 == 0:
        break
      header_crc32 = zlib.crc32(header[0:92]) % (1<<32)

    if primary:
      return header + bytes(bytearray(part_data))
    else:
      return bytes(bytearray(part_data)) + header

  def _generate_gpt_bin(self, partitions, settings):
    """Generate a bytearray representing partitions and settings.

    The blob will have three partition tables, laid out one after
    another: 1) Protective MBR (512 bytes); 2) Primary GPT (33*512
    bytes); and 3) Secondary GPT (33*512 bytes).

    The total size will be 34,304 bytes.

    Arguments:
      partitions: A list of Partition objects.
      settings: A Settings object.

    Returns:
      A bytearray() object.
    """
    protective_mbr = self._generate_protective_mbr(settings)
    primary_gpt = self._generate_gpt(partitions, settings)
    secondary_gpt = self._generate_gpt(partitions, settings, primary=False)
    ret = protective_mbr + primary_gpt + secondary_gpt
    return ret

  def _validate_disk_partitions(self, partitions, disk_size):
    """Check that a list of partitions have assigned offsets and fits on a
       disk of a given size.

    This function checks partition offsets and sizes to see if they may fit on
    a disk image.

    Arguments:
      partitions: A list of Partition objects.
      settings: Integer size of disk image.

    Raises:
      PackError: If checked condition is not satisfied.
    """
    for p in partitions:
      if not p.offset or p.offset < (GPT_NUM_LBAS + 1)*DISK_SECTOR_SIZE:
        raise PackError('Partition with label "{}" has no offset.'
                       .format(p.label))
      if not p.size or p.size < 0:
        raise PackError('Partition with label "{}" has no size.'
                        .format(p.label))
      if (p.offset + p.size) > (disk_size - GPT_NUM_LBAS*DISK_SECTOR_SIZE):
        raise PackError('Partition with label "{}" exceeds the disk '
                       'image size.'.format(p.label))

  def make_table(self,
                 inputs,
                 ab_suffixes=None,
                 partitions_offset_begin=None,
                 disk_size=None,
                 disk_alignment=None,
                 disk_guid=None,
                 guid_generator=None):
    """Implementation of the 'make_table' command.

    This function takes a list of input partition definition files,
    flattens them, expands A/B partitions, grows partitions, and lays
    out partitions according to alignment constraints.

    Arguments:
      inputs: List of JSON files to parse.
      ab_suffixes: List of the A/B suffixes (as a comma-separated string)
                   to use or None to not override.
      partitions_offset_begin: Size of disk partitions offset
                               begin or None to not override.
      disk_size: Size of disk or None to not override.
      disk_alignment: Disk alignment or None to not override.
      disk_guid: Disk GUID as a string or None to not override.
      guid_generator: A GuidGenerator or None to use the default.

    Returns:
      A tuple where the first argument is a JSON string for the resulting
      partitions and the second argument is the binary partition tables.

    Raises:
      BptParsingError: If an input file has an error.
      PackError: If another application-specific error occurs
    """
    partitions, settings = self._read_json(inputs)

    # Command-line arguments override anything specified in input
    # files.
    if disk_size:
      settings.disk_size = int(math.ceil(disk_size))
    if disk_alignment:
      settings.disk_alignment = int(disk_alignment)
    if partitions_offset_begin:
      settings.partitions_offset_begin = int(partitions_offset_begin)
    if ab_suffixes:
      settings.ab_suffixes = ab_suffixes.split(',')
    if disk_guid:
      settings.disk_guid = disk_guid

    if not guid_generator:
      guid_generator = GuidGenerator()

    # We need to know the disk size. Also round it down to ensure it's
    # a multiple of the sector size.
    if not settings.disk_size:
      raise PackError('Disk size not specified. Use --disk_size option '
                     'or specify it in an input file.\n')
    settings.disk_size = RoundToMultiple(settings.disk_size,
                                         DISK_SECTOR_SIZE,
                                         round_down=True)

    # Alignment must be divisible by disk sector size.
    if settings.disk_alignment % DISK_SECTOR_SIZE != 0:
      raise PackError(
          'Disk alignment size of {} is not divisible by {}.\n'.format(
              settings.disk_alignment, DISK_SECTOR_SIZE))

    if settings.partitions_offset_begin != 0:
      # Disk partitions offset begin size must be
      # divisible by disk sector size.
      if settings.partitions_offset_begin % settings.disk_alignment != 0:
        raise PackError(
            'Disk Partitions offset begin size of {} '
            'is not divisible by {}.\n'.format(
                settings.partitions_offset_begin, settings.disk_alignment))
      settings.partitions_offset_begin = max(settings.partitions_offset_begin,
                                           DISK_SECTOR_SIZE*(1 + GPT_NUM_LBAS))
      settings.partitions_offset_begin = RoundToMultiple(
          settings.partitions_offset_begin, settings.disk_alignment)

    # Expand A/B partitions and skip ignored partitions.
    expanded_partitions = []
    for p in partitions:
      if p.ignore:
        continue
      if p.ab and not p.ab_expanded:
        p.ab_expanded = True
        for suffix in settings.ab_suffixes:
          new_p = copy.deepcopy(p)
          new_p.label += suffix
          expanded_partitions.append(new_p)
      else:
        expanded_partitions.append(p)
    partitions = expanded_partitions

    # Expand Disk GUID if needed.
    if not settings.disk_guid or settings.disk_guid == JSON_KEYWORD_AUTO:
      settings.disk_guid = guid_generator.dispense_guid(0)

    # Sort according to 'position' attribute.
    partitions = sorted(partitions, key=cmp_to_key(lambda x, y: x.position - y.position))

    # Automatically generate GUIDs if the GUID is unset or set to
    # 'auto'. Also validate the rest of the fields.
    part_no = 1
    for p in partitions:
      p.expand_guid(guid_generator, part_no)
      p.validate()
      part_no += 1

    # Idenfify partition to grow and lay out partitions, ignoring the
    # one to grow. This way we can figure out how much space is left.
    #
    # Right now we only support a single 'grow' partition but we could
    # support more in the future by splitting up the available bytes
    # between them.
    grow_part = None
    # offset minimal size: DISK_SECTOR_SIZE*(1 + GPT_NUM_LBAS)
    offset = max(settings.partitions_offset_begin,
                 DISK_SECTOR_SIZE*(1 + GPT_NUM_LBAS))
    for p in partitions:
      if p.grow:
        if grow_part:
          raise PackError('Only a single partition can be automatically '
                         'grown.\n')
        grow_part = p
      else:
        # Ensure size is a multiple of DISK_SECTOR_SIZE by rounding up
        # (user may specify it as e.g. "1.5 GB" which is not divisible
        # by 512).
        p.size = RoundToMultiple(p.size, DISK_SECTOR_SIZE)
        # Align offset to disk alignment.
        offset = RoundToMultiple(offset, settings.disk_alignment)
        offset += p.size

    # After laying out (respecting alignment) all non-grow
    # partitions, check that the given disk size is big enough.
    if offset > settings.disk_size - DISK_SECTOR_SIZE*GPT_NUM_LBAS:
      raise PackError('Disk size of {} bytes is too small for partitions '
                     'totaling {} bytes.\n'.format(
                         settings.disk_size, offset))

    # If we have a grow partition, it'll starts at the next
    # available alignment offset and we can calculate its size as
    # follows.
    if grow_part:
      offset = RoundToMultiple(offset, settings.disk_alignment)
      grow_part.size = RoundToMultiple(
          settings.disk_size - DISK_SECTOR_SIZE*GPT_NUM_LBAS - offset,
          settings.disk_alignment,
          round_down=True)
      if grow_part.size < DISK_SECTOR_SIZE:
        raise PackError('Not enough space for partition "{}" to be '
                       'automatically grown.\n'.format(grow_part.label))

    # Now we can assign partition start offsets for all partitions,
    # including the grow partition.
    # offset minimal size: DISK_SECTOR_SIZE*(1 + GPT_NUM_LBAS)
    offset = max(settings.partitions_offset_begin,
                 DISK_SECTOR_SIZE*(1 + GPT_NUM_LBAS))
    for p in partitions:
      # Align offset.
      offset = RoundToMultiple(offset, settings.disk_alignment)
      p.offset = offset
      offset += p.size
    assert offset <= settings.disk_size - DISK_SECTOR_SIZE*GPT_NUM_LBAS

    json_str = self._generate_json(partitions, settings)

    gpt_bin = self._generate_gpt_bin(partitions, settings)

    return json_str, gpt_bin

  def _generate_pack_header(self, image_count, preload_size = 0, product_name = "", product_ver = "" ):
    preload_offset = 0
    if preload_size:
        preload_offset = PACKET_INFO_SIZE
    header_data = struct.pack(
      '<I'      # nMagic
      'I'       # nVersion
      '256s'    # szPrdName (128 UTF-16LE code units)
      '256s'    # szPrdVersion (128 UTF-16LE code units).
      'I'       # nPreLoadSize
      'I'       # nPreLoadOffset
      'I'       # nFileTCount
      'I'       # nFileTOffset
      '484s'    # bReserved
      'I',      # nCRC32
      PACKET_MAGIC,
      PACKET_STRUCT_VER,
      product_name.encode(encoding='utf-16le'),
      product_ver.encode(encoding='utf-16le'),
      preload_size,     # nPreLoadSize
      preload_offset,   # nPreLoadOffset
      image_count,
      PACKET_HEADER_SIZE,
      b"",
      0xFFFFFFFF
    )
    return header_data

  def _generate_pack_file_item(self, label, image_size, image_offset, file_type):
      data = struct.pack(
          '<72s'  # szPartitionName (36 UTF-16LE code units).
          'Q'     # llSize
          'Q'     # llOffset.
          'I'
          '36s',
          label.encode(encoding='utf-16le'),
          image_size,
          image_offset,
          file_type,
          b"")
      print("[info] partition:%16s, size:0x%08X, offset:0x%08X, type:%s" % (label,
                                                                      image_size,
                                                                      image_offset,
                                                                      STR_PACK_TYPE[file_type]))
      return data

  def _write_image_data_to_pac_file(self, in_file, out_file):
      left = in_file.image_size
      while left:
          read_size = MAX_BUFFER_SIZE
          if left < MAX_BUFFER_SIZE:
              read_size = left
          out_file.write(in_file.read(read_size))
          left -= read_size

  def _pack_sfs_image(self, sector_size, partitions, output, sfs_filename):
      if 0 == len(partitions):
          raise PackParsingError("sfs", 'Not find partition info.')
      if 0 == len(sfs_filename):
          return
      safety_offset = 0
      safety_bak_offset = 0
      boot_3rd_offset = 0
      for item in partitions:
          if item.label in SAFETY_PATITION_NAME:
              safety_offset = item.offset + sector_size
          elif item.label in SAFETY_BAK_PATITION_NAME:
              safety_bak_offset = item.offset + sector_size
          if safety_offset and safety_bak_offset:
              break
      if not safety_offset:
          raise PackParsingError("sfs", 'Not find os/dil partition.')
      sfs_obj = SFSImageHandler(sfs_filename)
      if not (sfs_obj.image_size == SFS_IMG_MAX_SIZE):
          raise PackParsingError("sfs", 'sfs image size over 128bytes.')
      output.write(sfs_obj.update_image_address(safety_offset, safety_bak_offset))

  def _get_sfs_image_address(self, sfs_filename):
      if 0 == len(sfs_filename):
          raise PackParsingError("sfs", 'Not find sfs file.')
          return
      sfs_obj = SFSImageHandler(sfs_filename)
      if sfs_obj.image_size < SFS_IMG_MAX_SIZE:
          raise PackParsingError("sfs", 'sfs image size < 128bytes.')
      print("[info] (boot0)normal image address = 0x%08X" % sfs_obj._normal_addr)
      print("[info] (boot1)backup image address = 0x%08X" % sfs_obj._backup_addr)
      print("[info] (boot2) third image address = 0x%08X" % sfs_obj._third_addr)
      return sfs_obj._normal_addr, sfs_obj._backup_addr, sfs_obj._third_addr

  def make_pac_image(self, output, bpt, images, das, preload, product_name, product_ver, allow_empty_partitions=False):
    """Implementation of the 'make_disk_image' command.

    This function takes in a list of partitions images and a bpt file
    for the purpose of creating a raw disk image with a protective MBR,
    primary and secondary GPT, and content for each partition as specified.

    Arguments:
      output: Output file where disk image is to be written to.
      bpt: BPT JSON file to parse.
      images: List of partition image paths to be combined (as specified by
              bpt).  Each element is of the form.
              'PARTITION_NAME:/PATH/TO/PARTITION_IMAGE'
      allow_empty_partitions: If True, partitions defined in |bpt| need not to
                              be present in |images|. Otherwise an exception is
                              thrown if a partition is referenced in |bpt| but
                              not in |images|.

    Raises:
      PackParsingError: If an image file has an error.
      PackError: If another application-specific error occurs.
    """
    # Generate partition list and settings.
    partitions, settings = self._read_json([bpt], ab_collapse=False)

    # Validated partition sizes and offsets.
    self._validate_disk_partitions(partitions, settings.disk_size)

    # Sort according to 'offset' attribute.
    partitions = sorted(partitions, key=cmp_to_key(lambda x, y: x.position - y.position))

    # Create necessary tables.
    protective_mbr = self._generate_protective_mbr(settings)
    primary_gpt = self._generate_gpt(partitions, settings)
    secondary_gpt = self._generate_gpt(partitions, settings, primary=False)

    # Start at 0 offset
    pack_file_array = []
    pac_data_offset = PACKET_INFO_SIZE
    output.seek(pac_data_offset)  # header(1K) + file_array(128*128)

    # Add preload file
    preload_size = 0
    if preload:
        _is_first_preload = True
        for name_path in preload:
            preload_name, preload_image = name_path.split(":")
            if preload_name.lower() in PRELOAD_NAMES:
                if preload_name.lower() in NEW_PRELOAD_NAMES:
                    global PACKET_STRUCT_VER
                    # PACKET_STRUCT_VER = 0x01
                _index = PRELOAD_NAMES.index(preload_name.lower())
                file_type = PRELOAD_TYPES[_index]
                preload_file = ImageHandler(preload_image)
                _size = preload_file.image_size
                if _is_first_preload:
                    _is_first_preload = False
                    preload_size = _size
                output.write(preload_file.read(_size))
                pack_file_array.append(self._generate_pack_file_item(preload_name, _size, pac_data_offset, file_type))
                pac_data_offset += _size
            else:
                raise PackParsingError("preload", "Invalid preload tag name.")

    # packet da files
    if das and len(das):
        for name_path in das:
            name, path = name_path.split(":")
            name = name.upper()
            if name not in DA_ID_LIST:
                err_info = "Invalid da id : %s, da id must be in %s" % (name, DA_ID_LIST)
                raise PackParsingError("da", err_info)
            input_image = ImageHandler(path)
            output.seek(pac_data_offset)
            self._write_image_data_to_pac_file(input_image, output)
            pack_file_array.append(self._generate_pack_file_item(name, input_image.image_size, \
                                                                 pac_data_offset, DA_ID_LIST.index(name)))
            pac_data_offset += input_image.image_size

    # write mbr and primary gpt.
    output.write(protective_mbr)
    output.write(primary_gpt)
    output.write(secondary_gpt)
    gpt_len = len(protective_mbr) + len(primary_gpt) + len(secondary_gpt)
    pack_file_array.append(self._generate_pack_file_item("partition", gpt_len, pac_data_offset, E_PACK_GPT_FILE))
    pac_data_offset += gpt_len

    # Create mapping of partition name to partition image file.
    image_file_names = {}
    _a = settings.ab_suffixes[0]
    _b = settings.ab_suffixes[1]
    partition_list = [p.label for p in partitions]
    try:
      for name_path in images:
        name, path = name_path.split(":")
        image_file_names[name] = path
        if name not in partition_list and \
                ((name[-2:] == _a and name[0:-2] not in partition_list) or name+_a not in partition_list):
            raise PackError('{} partition do not exist, {}.'.format(name, name_path))
        if not os.path.exists(path):
            raise PackError('file do not exist, {}.'.format(name_path))
    except ValueError as e:
        raise PackParsingError(name_path, 'Bad image argument {}.'.format(images))

    # check image files
    key_list = list(image_file_names.keys())
    for k in key_list:
        add_a_suffix = k + _a
        rm_a_suffix = k[0:-2]
        if k not in partition_list and add_a_suffix in partition_list:
            image_file_names[add_a_suffix] = image_file_names.pop(k)
        elif k not in partition_list and name[-2:] == _a and rm_a_suffix in partition_list:
            image_file_names[rm_a_suffix] = image_file_names.pop(k)

    # Read image and insert in correct offset.
    for p in partitions:
        file_type = E_PACK_IMG_FILE
        if p.label not in image_file_names:
            if allow_empty_partitions:
                if not (p.label[-2:] == _b):
                    _padding_len = 0
                    pack_file_array.append(self._generate_pack_file_item(p.label, _padding_len, pac_data_offset, file_type))
                    pac_data_offset += _padding_len
                    print("[warning] %s partition is empty!" % p.label)
                continue
            else:
                raise PackParsingError(bpt.name, 'No content specified for partition with label {}'.format(p.label))

        file_extension = get_file_extension(image_file_names[p.label])
        if file_extension.lower() == ".pac":
            file_type = E_PACK_PAC_FILE

        input_image = ImageHandler(image_file_names[p.label])
        if p.size < input_image.raw_image_size:
            msg = "Image size is over its partition with label \"%s\",file is %s, Image size is 0x%X, Partition size is 0x%X\nmaybe you should check partition size definition in %s" % \
                  (p.label, image_file_names[p.label], input_image.raw_image_size, p.size, bpt.name)
            raise PackParsingError(bpt.name, msg)

        output.seek(pac_data_offset)
        self._write_image_data_to_pac_file(input_image, output)
        file_size = input_image.image_size
        pack_file_array.append(self._generate_pack_file_item(p.label, file_size, pac_data_offset, file_type))
        pac_data_offset += file_size

    # Put padding.
    if not (pac_data_offset == output.tell()):
        output.seek(pac_data_offset - 1)
        output.write(b'\0')

    #  Write packet header and file array.
    output.seek(0)
    header_data = self._generate_pack_header(len(pack_file_array), preload_size, product_name, product_ver)
    output.write(header_data)
    for file_t in pack_file_array:
      output.write(file_t)

  def make_pac_image_no_gpt(self, output, images, das, preload, product_name, product_ver, allow_empty_partitions=False):
    """Implementation of the 'make_pac_image_no_gpt' command.

    Arguments:
      output: Output file where disk image is to be written to.
      images: List of partition image paths to be combined (as specified by
              bpt).  Each element is of the form.
              'ADDRESS:/PATH/TO/PARTITION_IMAGE'
      allow_empty_partitions: If True, partitions defined in |bpt| need not to
                              be present in |images|. Otherwise an exception is
                              thrown if a partition is referenced in |bpt| but
                              not in |images|.

    Raises:
      PackParsingError: If an image file has an error.
      PackError: If another application-specific error occurs.
    """
    # Start at 0 offset
    pack_file_array = []
    pac_data_offset = PACKET_INFO_SIZE
    output.seek(pac_data_offset)  # header(1K) + file_array(128*128)

    # Add preload file
    _normal_addr = 0
    _backup_addr = 0
    _third_addr = 0
    preload_size = 0
    if preload:
        _is_first_preload = True
        for name_path in preload:
            preload_name, preload_image = name_path.split(":")
            if preload_name.lower() in PRELOAD_NAMES:
                if preload_name.lower() in NEW_PRELOAD_NAMES:
                    global PACKET_STRUCT_VER
                    # PACKET_STRUCT_VER = 0x01
                _index = PRELOAD_NAMES.index(preload_name.lower())
                file_type = PRELOAD_TYPES[_index]
                if file_type == E_PACK_SFS_FILE:
                    _normal_addr, _backup_addr, _third_addr = self._get_sfs_image_address(preload_image)
                preload_file = ImageHandler(preload_image)
                _size = preload_file.image_size
                if _is_first_preload:
                    _is_first_preload = False
                    preload_size = _size
                output.write(preload_file.read(_size))
                pack_file_array.append(self._generate_pack_file_item(preload_name, _size, pac_data_offset, file_type))
                pac_data_offset += _size
            else:
                raise PackParsingError("preload", "Invalid preload tag name.")

    # packet da files
    if das and len(das):
        for name_path in das:
            name, path = name_path.split(":")
            name = name.upper()
            if name not in DA_ID_LIST:
                err_info = "Invalid da id : %s, da id must be in %s" % (name, DA_ID_LIST)
                raise PackParsingError("da", err_info)
            input_image = ImageHandler(path)
            output.seek(pac_data_offset)
            self._write_image_data_to_pac_file(input_image, output)
            pack_file_array.append(self._generate_pack_file_item(name, input_image.image_size, \
                                                                 pac_data_offset, DA_ID_LIST.index(name)))
            pac_data_offset += input_image.image_size

    # Create mapping of partition name to partition image file.
    image_file_names = {}
    if not images is None and len(images):
        try:
          for name_path in images:
            name, path = name_path.split(":")
            _addr = self._str_to_number(name)
            image_file_names[_addr] = path
            if not os.path.exists(path):
                raise PackError('file do not exist, {}.'.format(name_path))
        except ValueError as e:
            raise PackParsingError(name_path, 'Bad image argument {}.'.format(images))

    # Read image and insert in correct offset.
    # Sort according to 'position' attribute.
    _addr_list = sorted(image_file_names)
    _last_end = 0
    for _addr in _addr_list:
        input_image = ImageHandler(image_file_names[_addr])
        if _last_end and _addr < _last_end:
            msg = "the \"0x%X\" partition overwrites the previous partition, file is \"%s\", Image size is 0x%X\n" % \
                  (_addr, image_file_names[_addr], input_image.raw_image_size)
            raise PackParsingError("0x%X" % _addr, msg)

        output.seek(pac_data_offset)
        self._write_image_data_to_pac_file(input_image, output)
        file_size = input_image.image_size
        pack_file_array.append(self._generate_pack_file_item("0x%X" % _addr, file_size, pac_data_offset, E_PACK_IMG_FILE))
        pac_data_offset += file_size
        _last_end = _addr + input_image.raw_image_size

    # Put padding.
    if not (pac_data_offset == output.tell()):
        output.seek(pac_data_offset - 1)
        output.write('\0')

    #  Write packet header and file array.
    output.seek(0)
    header_data = self._generate_pack_header(len(pack_file_array), preload_size, product_name, product_ver)
    output.write(header_data)

    # sort pack files info
    _count = len(pack_file_array)
    _boot_type = [E_PACK_FBL_FILE, E_PACK_SBL_FILE, E_PACK_TBL_FILE]
    _sfs_addr_info = [_normal_addr, _backup_addr, _third_addr]
    for i in range(_count):
      _partition_name, _size,_offset, _type= struct.unpack("<72sQQI36x", pack_file_array[i])
      if _type not in [E_PACK_FBL_FILE, E_PACK_SBL_FILE, E_PACK_TBL_FILE, E_PACK_IMG_FILE]:
        continue
      min_index = i
      _name_current = self._words2string(_partition_name)
      if _type in _boot_type:
        _name_current = hex(_sfs_addr_info[_boot_type.index(_type)])
      for j in range(i+1, _count):
        _partition_name_next, _size_next,_offset_next, _type_next= struct.unpack("<72sQQI36x", pack_file_array[j])
        if _type_next not in [E_PACK_FBL_FILE, E_PACK_SBL_FILE, E_PACK_TBL_FILE, E_PACK_IMG_FILE]:
          continue
        _name_next = self._words2string(_partition_name_next)
        if _type_next in _boot_type:
          _name_next = hex(_sfs_addr_info[_boot_type.index(_type_next)])
        if eval(_name_current) > eval(_name_next):
            min_index = j
            _name_current = _name_next
      if not i == min_index:
        pack_file_array[i], pack_file_array[min_index] = pack_file_array[min_index], pack_file_array[i]

    for file_t in pack_file_array:
      output.write(file_t)

  def _words2string(self, words):
    string = ""
    for i in range(len(words)):
        if i % 2 == 0:
            if not words[i] == 0:
                string += "%c" % words[i]
    return string.rstrip('\x00')

  def _str_to_number(self, str):
      str = str.lower().strip()
      _number = 0
      if str.find('0x') == -1:
          _number = int(str)
      else:
          _number = int(str, 16)
      return _number


class PackTool(object):
  """Object for pack tool command-line tool."""

  def __init__(self):
    """Initializer method."""
    self.packet = Packet()

  def run(self, argv):
    """Command-line processor.

    Arguments:
      argv: Pass sys.argv from main.
    """
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers(title='subcommands')

    sub_parser = subparsers.add_parser(
        'version',
        help='Prints version of packtool.')
    sub_parser.set_defaults(func=self.version)

    sub_parser = subparsers.add_parser(
        'make_table',
        help='Lays out partitions and creates partition table.')
    sub_parser.add_argument('--input',
                            help='Path to partition definition file.',
                            type=argparse.FileType('r'),
                            action='append')
    sub_parser.add_argument('--ab_suffixes',
                            help='Set or override A/B suffixes.')
    sub_parser.add_argument('--partitions_offset_begin',
                            help='Set or override disk partitions '
                                 'offset begin size.',
                            type=ParseSize)
    sub_parser.add_argument('--disk_size',
                            help='Set or override disk size.',
                            type=ParseSize)
    sub_parser.add_argument('--disk_alignment',
                            help='Set or override disk alignment.',
                            type=ParseSize)
    sub_parser.add_argument('--disk_guid',
                            help='Set or override disk GUID.',
                            type=ParseGuid)
    sub_parser.add_argument('--output_json',
                            help='JSON output file name.',
                            type=argparse.FileType('w'))
    sub_parser.add_argument('--output_gpt',
                            help='Output file name for MBR/GPT/GPT file.',
                            type=argparse.FileType('wb'))
    sub_parser.set_defaults(func=self.make_table)

    sub_parser = subparsers.add_parser(
        'make_pac_image',
        help='Creates pack image for program tool.')
    sub_parser.add_argument('--output',
                            help='Path to image output.',
                            type=argparse.FileType('wb'),
                            required=True)
    sub_parser.add_argument('--input',
                            help='Path to bpt file input.',
                            type=argparse.FileType('r'),
                            required=True)
    sub_parser.add_argument('--image',
                            help='Partition name and path to image file.',
                            metavar='PARTITION_NAME:PATH',
                            action='append')
    # FDA : spl.img
    # OPSIDA : ospi_prog
    # DLOADER : dloader
    sub_parser.add_argument('--da',
                            help='Download agent name and path to image file.',
                            metavar='DA_NAME:PATH',
                            action='append')
    sub_parser.add_argument('--preload',
                            help='Partition name and path to image file.[spl/sfs:file]',
                            metavar='PARTITION_NAME:PATH',
                            action='append'
                            )
    sub_parser.add_argument('--product',
                            help='product name.',
                            type=str,
                            default=""
                            )
    sub_parser.add_argument('--version',
                            help='Product version.',
                            type=str,
                            default=""
                            )
    sub_parser.add_argument('--allow_empty_partitions',
                            help='Allow skipping partitions in bpt file.',
                            action='store_true')
    sub_parser.set_defaults(func=self.make_pac_image)

    # no gpt solution
    sub_parser = subparsers.add_parser(
        'make_pac_image_no_gpt',
        help='Creates no partition table pack image for program tool.')
    sub_parser.add_argument('--output',
                            help='Path to image output.',
                            type=argparse.FileType('wb'),
                            required=True)
    sub_parser.add_argument('--image',
                            help='address and path to image file.',
                            metavar='ADDRESS:PATH',
                            action='append')
    # FDA : spl.img
    # OPSIDA : ospi_prog
    # DLOADER : dloader
    sub_parser.add_argument('--da',
                            help='Download agent name and path to image file.',
                            metavar='DA_NAME:PATH',
                            action='append')
    sub_parser.add_argument('--preload',
                            help='Partition name and path to image file.[spl/sfs:file]',
                            metavar='PARTITION_NAME:PATH',
                            action='append'
                            )
    sub_parser.add_argument('--product',
                            help='product name.',
                            type=str,
                            default=""
                            )
    sub_parser.add_argument('--version',
                            help='Product version.',
                            type=str,
                            default=""
                            )
    sub_parser.add_argument('--allow_empty_partitions',
                        help='Allow skipping partitions in bpt file.',
                        action='store_true')
    sub_parser.set_defaults(func=self.make_pac_image_no_gpt)

    args = parser.parse_args(argv[1:])
    args.func(args)

  def version(self, _):
    """Implements the 'version' sub-command."""
    print("{}.{}".format(PACKTOOL_VERSION_MAJOR, PACKTOOL_VERSION_MINOR))

  def make_table(self, args):
    """Implements the 'make_table' sub-command."""
    if not args.input:
      print('Option --input is required one or more times.\n')
      return False

    try:
      (json_str, gpt_bin) = self.packet.make_table(args.input, args.ab_suffixes,
                                                args.partitions_offset_begin,
                                                args.disk_size,
                                                args.disk_alignment,
                                                args.disk_guid)
    except PackParsingError as e:
        print('{}: Error parsing: {}\n'.format(e.filename, e.message))
        return False
    except PackError as e:
        print('Error : {}\n'.format(e.message))
        return False

    if args.output_json:
      args.output_json.write(json_str)
    if args.output_gpt:
      args.output_gpt.write(gpt_bin)
    return True

  def make_pac_image(self, args):
    """Implements the 'make_pac_image' sub-command."""
    if not args.input:
      error('Option --input is required.\n')
    if not args.output:
      error('Option --ouptut is required.\n')

    try:
      self.packet.make_pac_image(args.output,
                                 args.input,
                                 args.image,
                                 args.da,
                                 args.preload,
                                 args.product,
                                 args.version,
                                 args.allow_empty_partitions
                                 )
    except PackParsingError as e:
      error('{}: Error parsing: {}\n'.format(e.filename, e.message))
    except 'PackError' as e:
      error('Error : {}\n'.format(e.message))

  def make_pac_image_no_gpt(self, args):
    """Implements the 'make_pac_image_no_gpt' sub-command."""
    if not args.output:
        error('Option --ouptut is required.\n')

    try:
        self.packet.make_pac_image_no_gpt(
            args.output,
            args.image,
            args.da,
            args.preload,
            args.product,
            args.version,
            args.allow_empty_partitions)
    except PackParsingError as e:
        error('{}: Error parsing: {}\n'.format(e.filename, e.message))
    except 'PackError' as e:
        error('Error : {}\n'.format(e.message))


if __name__ == '__main__':
    tool = PackTool()
    tool.run(sys.argv)