// Copyright 2021 The Fuchsia 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 "target_archive/target_archive.h"

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//
//
//

// clang-format off
#define TARGET_ARCHIVE_BUFLEN       8192
#define TARGET_ARCHIVE_BINARY_ALIGN 8
// clang-format on

//
// Target Archive
//

static void
target_archive_usage(char const * argv[])
{
  fprintf(
    stderr,
    "Usage: %s <target archive name> <rebased target archive filename prefix> [ <binary file> ]+\n"
    "\n"
    "Concatenates one or more binaries prefixed by a table containing \n"
    "the number of binaries and the offset and size of each binary.\n"
    "\n"
    "  - Offsets are relative to the end of the entries[] table.\n"
    "  - Offsets and sizes are in bytes.\n"
    "  - Offsets and sizes are 64-bit.\n"
    "  - Binaries and their offsets are 8-byte aligned.\n"
    "\n"
    "Three files are output:\n"
    "  - <output_name>.ar  : Target archive\n"
    "  - <output_name>.S\n : Linkable source file for including target archive\n"
    "  - <output_name>.h\n : Include file containing linkable symbol name of target archive\n",
    argv[0]);
}

//
// Copy files_in[] to file_out.
//
// NOTE: Use of `sendfile()` probably isn't worth loss of portability.
//

static void
target_archive_copy(FILE *                        file_out,
                    FILE **                       files_in,
                    struct target_archive_entry * entries,
                    uint32_t                      count,
                    int * const                   exit_code)
{
  if (count == 0)
    {
      return;
    }

  char * buf = malloc(TARGET_ARCHIVE_BUFLEN);

  if (buf == NULL)
    {
      exit(EXIT_FAILURE);
    }

  while (true)
    {
      // copy until error
      while (true)
        {
          size_t const bytes = fread(buf, 1, TARGET_ARCHIVE_BUFLEN, *files_in);

          if (fwrite(buf, 1, bytes, file_out) != bytes)
            {
              *exit_code = EXIT_FAILURE;
            }

          entries->size += bytes;

          if (bytes < TARGET_ARCHIVE_BUFLEN)
            {
              if (ferror(*files_in))
                {
                  *exit_code = EXIT_FAILURE;
                }

              break;
            }
        }

      // pad with zeroes to next 8-byte offset
      uint32_t const rem          = (entries->size & (TARGET_ARCHIVE_BINARY_ALIGN - 1));
      bool const     is_unaligned = (rem != 0);
      uint32_t const skip         = is_unaligned ? TARGET_ARCHIVE_BINARY_ALIGN - rem : 0;

      if (is_unaligned)
        {
          // store up to 7 zero bytes
          uint8_t const zeroes[TARGET_ARCHIVE_BINARY_ALIGN - 1] = { 0 };

          if (fwrite(zeroes, 1, skip, file_out) != skip)
            {
              *exit_code = EXIT_FAILURE;
            }
        }

      if (--count == 0)
        {
          break;
        }

      uint64_t const offset_ru = entries->offset + entries->size + skip;

      ++entries;
      ++files_in;

      entries->offset = offset_ru;
    }

  free(buf);
}

//
//
//

static bool
target_archive_verify(FILE ** files, char const * argv[], uint32_t count)
{
  bool is_verified = true;

  for (uint32_t ii = 0; ii < count; ii++)
    {
      if (files[ii] == NULL)
        {
          is_verified = false;

          fprintf(stderr, "File not found: %s\n", argv[ii]);
        }
    }

  return is_verified;
}

//
//
//

static void
target_archive_str_replace(char file_name[], size_t file_name_len, char from, char to)
{
  for (size_t ii = 0; ii < file_name_len; ii++)
    {
      if (file_name[ii] == from)
        {
          file_name[ii] = to;
        }
    }
}

//
//
//

static void
target_archive_write_dot_h(char const * generator, char const * name, char const * rebased_name)
{
  //
  // What is the name of the include file?
  //
  size_t const name_len      = strlen(rebased_name);
  size_t const file_name_len = name_len + strlen(".h") + 1;

  char file_name[file_name_len];

  strcpy(file_name, rebased_name);
  strcpy(file_name + name_len, ".h");

  FILE * file = fopen(file_name, "w");

  if (file == NULL)
    {
      exit(EXIT_FAILURE);
    }

  //
  // Symbol name can be long but that's OK
  //
  target_archive_str_replace(file_name, name_len, '/', '_');
  file_name[name_len] = '\0';

  fprintf(file,
          "// Copyright 2021 The Fuchsia Authors.All rights reserved.\n"
          "// Use of this source code is governed by a BSD - style license that can be\n"
          "// found in the LICENSE file.\n"
          "//\n"
          "// WARNING: File generated by %s\n"
          "\n",
          generator);

  fprintf(file,
          "#pragma once\n"
          "\n"
          "#include \"target_archive/target_archive.h\"\n"
          "\n"
          "#ifdef __cplusplus\n"
          "extern \"C\" {\n"
          "#endif\n"
          "\n"
          "extern struct target_archive_header const %s[];\n"
          "\n"
          "#ifdef __cplusplus\n"
          "}\n"
          "#endif\n",
          name);

  fclose(file);
}

//
//
//

static void
target_archive_write_dot_S(char const * generator, char const * name, char const * rebased_name)
{
  //
  // What is the name of the include file?
  //
  size_t const name_len      = strlen(rebased_name);
  size_t const file_name_len = name_len + strlen(".S") + 1;

  char file_name[file_name_len];

  strcpy(file_name, rebased_name);
  strcpy(file_name + name_len, ".S");

  FILE * file = fopen(file_name, "w");

  if (file == NULL)
    {
      exit(EXIT_FAILURE);
    }

  //
  // Symbol name can be long but that's OK
  //
  fprintf(file,
          "# Copyright 2021 The Fuchsia Authors.All rights reserved.\n"
          "# Use of this source code is governed by a BSD - style license that can be\n"
          "# found in the LICENSE file.\n"
          "#\n"
          "# WARNING: File generated by %s\n"
          "\n",
          generator);

  fprintf(file,
          ".section .rodata\n"
          "\n"
          ".global %s\n"
          ".type %s, @object\n"
          ".align 8\n"
          "\n"
          "%s: .incbin \"%s.ar\"\n"
          "\n",
          name,
          name,
          name,
          rebased_name);

  fclose(file);
}

//
//
//

static void
target_archive_dump_linkables(char const * argv[])
{
  target_archive_write_dot_h(argv[0], argv[1], argv[2]);
  target_archive_write_dot_S(argv[0], argv[1], argv[2]);
}

//
//
//

int
main(int argc, char const * argv[])
{
  if (argc < 3)
    {
      target_archive_usage(argv);

      exit(EXIT_FAILURE);
    }

  //
  // Dump linkable files first
  //
  target_archive_dump_linkables(argv);

  //
  // How many files to concatenate?
  //
  uint32_t const file_count = argc - 2;
  uint32_t const read_count = argc - 3;

  //
  // Create header
  //
  size_t const entries_size = sizeof(struct target_archive_entry) * read_count;
  size_t const header_size  = sizeof(struct target_archive_header) + entries_size;

  struct target_archive_header * const header = calloc(1, header_size);

  if (header == NULL)
    {
      exit(EXIT_FAILURE);
    }

  struct target_archive_entry * entries = header->entries;

  header->magic = TARGET_ARCHIVE_MAGIC;
  header->count = read_count;

  //
  // What is the file name of the target archive?
  //
  size_t const name_len      = strlen(argv[2]);
  size_t const file_name_len = name_len + strlen(".ar") + 1;

  char file_name[file_name_len];

  strcpy(file_name, argv[2]);
  strcpy(file_name + name_len, ".ar");

  //
  // Blindly open all files
  //
  FILE ** files = calloc(file_count, sizeof(*files));

  if (files == NULL)
    {
      exit(EXIT_FAILURE);
    }

  files[0] = fopen(file_name, "wb");

  for (uint32_t ii = 1; ii < file_count; ii++)
    {
      files[ii] = fopen(argv[2 + ii], "rb");
    }

  //
  // Verify all files were opened
  //
  int exit_code = EXIT_FAILURE;

  if (target_archive_verify(files, argv + 2, file_count))
    {
      exit_code = EXIT_SUCCESS;

      //
      // Copy all files
      //
      if (fseek(files[0], (long)header_size, SEEK_SET) != 0)
        {
          exit_code = EXIT_FAILURE;
        }

      target_archive_copy(files[0], files + 1, entries, read_count, &exit_code);

      //
      // Write header
      //
      if (fseek(files[0], 0, SEEK_SET) != 0)
        {
          exit_code = EXIT_FAILURE;
        }

      if (fwrite(header, 1, header_size, files[0]) != header_size)
        {
          exit_code = EXIT_FAILURE;
        }
    }

  //
  // Cleanup
  //
  for (uint32_t ii = 0; ii < file_count; ii++)
    {
      if (files[ii] != NULL)
        {
          fclose(files[ii]);
        }
    }

  free(files);
  free(header);

  exit(exit_code);
}

//
//
//