// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "cgpt.h"

#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <uuid/uuid.h>

#include "cgptlib_internal.h"

static void Usage(void)
{
  printf("\nUsage: %s prioritize [OPTIONS] DRIVE\n\n"
         "Reorder the priority of all active ChromeOS Kernel partitions.\n\n"
         "Options:\n"
         "  -P NUM       Highest priority to use in the new ordering. The\n"
         "                 other partitions will be ranked in decreasing\n"
         "                 priority while preserving their original order.\n"
         "                 If necessary the lowest ranks will be coalesced.\n"
         "                 No active kernels will be lowered to priority 0.\n"
         "  -i NUM       Specify the partition to make the highest in the new\n"
         "                 order.\n"
         "  -f           Friends of the given partition (those with the same\n"
         "                 starting priority) are also updated to the new\n"
         "                 highest priority.\n"
         "\n"
         "With no options this will set the lowest active kernel to\n"
         "priority 1 while maintaining the original order.\n"
         "\n", progname);
}

//////////////////////////////////////////////////////////////////////////////
// I want a sorted list of priority groups, where each element in the list
// contains an unordered list of GPT partition numbers. This is a stupid
// implementation, but our needs are simple and don't justify the time or space
// it would take to write a "better" one.
#define MAX_GROUPS 17                   // 0-15, plus one "higher"

typedef struct {
  int priority;                         // priority of this group
  int num_parts;                        // number of partitions in this group
  uint32_t *part;                       // array of partitions in this group
} group_t;

typedef struct {
  int max_parts;                       // max number of partitions in any group
  int num_groups;                      // number of non-empty groups
  group_t group[MAX_GROUPS];           // array of groups
} group_list_t;


static group_list_t *NewGroupList(int max_p) {
  int i;
  group_list_t *gl = (group_list_t *)malloc(sizeof(group_list_t));
  require(gl);
  gl->max_parts = max_p;
  gl->num_groups = 0;
  // reserve space for the maximum number of partitions in every group
  for (i=0; i<MAX_GROUPS; i++) {
    gl->group[i].priority = -1;
    gl->group[i].num_parts = 0;
    gl->group[i].part = (uint32_t *)malloc(sizeof(uint32_t) * max_p);
    require(gl->group[i].part);
  }

  return gl;
}

static void FreeGroups(group_list_t *gl) {
  int i;
  for (i=0; i<MAX_GROUPS; i++)
    free(gl->group[i].part);
  free(gl);
}

static void AddToGroup(group_list_t *gl, int priority, int partition) {
  int i;
  // See if I've already got a group with this priority
  for (i=0; i<gl->num_groups; i++)
    if (gl->group[i].priority == priority)
      break;
  if (i == gl->num_groups) {
    // no, add a group
    require(i < MAX_GROUPS);
    gl->num_groups++;
    gl->group[i].priority = priority;
  }
  // add the partition to it
  int j = gl->group[i].num_parts;
  gl->group[i].part[j] = partition;
  gl->group[i].num_parts++;
}

static void ChangeGroup(group_list_t *gl, int old_priority, int new_priority) {
  int i;
  for (i=0; i<gl->num_groups; i++)
    if (gl->group[i].priority == old_priority) {
      gl->group[i].priority = new_priority;
      break;
    }
}

static void SortGroups(group_list_t *gl) {
  int i, j;
  group_t tmp;

  // straight insertion sort is fast enough
  for (i=1; i<gl->num_groups; i++) {
    tmp = gl->group[i];
    for (j=i; j && (gl->group[j-1].priority < tmp.priority); j--)
      gl->group[j] = gl->group[j-1];
    gl->group[j] = tmp;
  }
}


//////////////////////////////////////////////////////////////////////////////

int cmd_prioritize(int argc, char *argv[]) {
  struct drive drive;
  uint32_t set_partition = 0;
  int set_friends = 0;
  int max_priority = 0;
  int priority;
  int orig_priority = 0;
  int gpt_retval;
  GptEntry *entry;
  uint32_t index;
  uint32_t max_part;
  int num_kernels;
  int i,j;
  group_list_t *groups;

  int c;
  int errorcnt = 0;
  char *e = 0;

  opterr = 0;                     // quiet, you
  while ((c=getopt(argc, argv, ":hi:fP:")) != -1)
  {
    switch (c)
    {
    case 'i':
      set_partition = (uint32_t)strtoul(optarg, &e, 0);
      if (!*optarg || (e && *e))
      {
        Error("invalid argument to -%c: \"%s\"\n", c, optarg);
        errorcnt++;
      }
      break;
    case 'f':
      set_friends = 1;
      break;
    case 'P':
      max_priority = (int)strtol(optarg, &e, 0);
      if (!*optarg || (e && *e))
      {
        Error("invalid argument to -%c: \"%s\"\n", c, optarg);
        errorcnt++;
      }
      if (max_priority < 1 || max_priority > 15) {
        Error("value for -%c must be between 1 and 15\n", c);
        errorcnt++;
      }
      break;

    case 'h':
      Usage();
      return CGPT_OK;
    case '?':
      Error("unrecognized option: -%c\n", optopt);
      errorcnt++;
      break;
    case ':':
      Error("missing argument to -%c\n", optopt);
      errorcnt++;
      break;
    default:
      errorcnt++;
      break;
    }
  }
  if (errorcnt)
  {
    Usage();
    return CGPT_FAILED;
  }

  if (set_friends && !set_partition) {
    Error("the -f option is only useful with the -i option\n");
    Usage();
    return CGPT_FAILED;
  }

  if (optind >= argc) {
    Error("missing drive argument\n");
    return CGPT_FAILED;
  }

  if (CGPT_OK != DriveOpen(argv[optind], &drive))
    return CGPT_FAILED;

  if (GPT_SUCCESS != (gpt_retval = GptSanityCheck(&drive.gpt))) {
    Error("GptSanityCheck() returned %d: %s\n",
          gpt_retval, GptError(gpt_retval));
    return CGPT_FAILED;
  }

  max_part = GetNumberOfEntries(&drive.gpt);

  if (set_partition) {
    if (set_partition < 1 || set_partition > max_part) {
      Error("invalid partition number: %d (must be between 1 and %d\n",
            set_partition, max_part);
      goto bad;
    }
    index = set_partition - 1;
    // it must be a kernel
    entry = GetEntry(&drive.gpt, PRIMARY, index);
    if (!GuidEqual(&entry->type, &guid_chromeos_kernel)) {
      Error("partition %d is not a ChromeOS kernel\n", set_partition);
      goto bad;
    }
  }

  // How many kernel partitions do I have?
  num_kernels = 0;
  for (i = 0; i < max_part; i++) {
    entry = GetEntry(&drive.gpt, PRIMARY, i);
    if (GuidEqual(&entry->type, &guid_chromeos_kernel))
      num_kernels++;
  }

  if (!num_kernels)
    // nothing to do, so don't
    goto good;

  // Determine the current priority groups
  groups = NewGroupList(num_kernels);
  for (i = 0; i < max_part; i++) {
    entry = GetEntry(&drive.gpt, PRIMARY, i);
    if (!GuidEqual(&entry->type, &guid_chromeos_kernel))
      continue;

    priority = GetPriority(&drive.gpt, PRIMARY, i);

    // Is this partition special?
    if (set_partition && (i+1 == set_partition)) {
      orig_priority = priority;         // remember the original priority
      if (set_friends)
        AddToGroup(groups, priority, i); // we'll move them all later
      else
        AddToGroup(groups, 99, i);      // move only this one
    } else {
      AddToGroup(groups, priority, i);  // just remember
    }
  }

  // If we're including friends, then change the original group priority
  if (set_partition && set_friends) {
    ChangeGroup(groups, orig_priority, 99);
  }

  // Sorting gives the new order. Now we just need to reassign the
  // priorities.
  SortGroups(groups);

  // We'll never lower anything to zero, so if the last group is priority zero
  // we can ignore it.
  i = groups->num_groups;
  if (groups->group[i-1].priority == 0)
    groups->num_groups--;

  // Where do we start?
  if (max_priority)
    priority = max_priority;
  else
    priority = groups->num_groups > 15 ? 15 : groups->num_groups;

  // Figure out what the new values should be
  for (i=0; i<groups->num_groups; i++) {
    groups->group[i].priority = priority;
    if (priority > 1)
      priority--;
  }

  // Now apply the ranking to the GPT
  for (i=0; i<groups->num_groups; i++)
    for (j=0; j<groups->group[i].num_parts; j++)
      SetPriority(&drive.gpt, PRIMARY,
                  groups->group[i].part[j], groups->group[i].priority);

  FreeGroups(groups);


  // Write it all out
good:
  RepairEntries(&drive.gpt, MASK_PRIMARY);
  RepairHeader(&drive.gpt, MASK_PRIMARY);

  drive.gpt.modified |= (GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1 |
                         GPT_MODIFIED_HEADER2 | GPT_MODIFIED_ENTRIES2);
  UpdateCrc(&drive.gpt);

  return DriveClose(&drive, 1);

bad:
  (void) DriveClose(&drive, 0);
  return CGPT_FAILED;
}