#define _POSIX_C_SOURCE 200809L

#include "mpd_common.h"

#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <poll.h>
#include <signal.h>
#include <spawn.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
#include <wordexp.h>

extern char **environ;

enum helper_state {
  HELPER_UNRESOLVED,
  HELPER_READY,
  HELPER_FAILED,
};

static enum helper_state profile_helper_state;

#define HELPER_DEFAULT_TIMEOUT_SECONDS 10U
#define HELPER_MAX_TIMEOUT_SECONDS 3600U
#define PLAYER_SNAPSHOT_RETRIES 3U

static bool safe_helper_value(const char *value) {
  if (*value == '\0')
    return false;
  for (const unsigned char *cursor = (const unsigned char *)value;
       *cursor != '\0'; cursor++) {
    if (*cursor < 0x20U || *cursor == 0x7fU)
      return false;
  }
  return true;
}

static bool parse_helper_port(const char *value) {
  if (*value == '\0' || *value == '-')
    return false;
  errno = 0;
  char *end;
  unsigned long port = strtoul(value, &end, 10);
  return errno == 0 && *end == '\0' && port > 0UL && port <= 65535UL;
}

static unsigned helper_timeout_seconds(void) {
  const char *configured = getenv("MPD_CONFIG_HELPER_TIMEOUT");
  if (configured == NULL || *configured == '\0')
    return HELPER_DEFAULT_TIMEOUT_SECONDS;

  size_t timeout;
  if (!mt_parse_size(configured, &timeout) || timeout == 0U ||
      timeout > HELPER_MAX_TIMEOUT_SECONDS) {
    fprintf(stderr,
            "mpd: MPD_CONFIG_HELPER_TIMEOUT must be between 1 and %u "
            "seconds\n",
            HELPER_MAX_TIMEOUT_SECONDS);
    return 0U;
  }
  return (unsigned)timeout;
}

static bool monotonic_now(struct timespec *value) {
  if (clock_gettime(CLOCK_MONOTONIC, value) == 0)
    return true;
  perror("mpd: read monotonic clock");
  return false;
}

static int milliseconds_until(const struct timespec *deadline) {
  struct timespec now;
  if (!monotonic_now(&now))
    return -1;
  time_t seconds = deadline->tv_sec - now.tv_sec;
  long nanoseconds = deadline->tv_nsec - now.tv_nsec;
  if (nanoseconds < 0) {
    seconds--;
    nanoseconds += 1000000000L;
  }
  if (seconds < 0 || (seconds == 0 && nanoseconds == 0))
    return 0;
  if (seconds > (time_t)(INT_MAX / 1000))
    return INT_MAX;
  long milliseconds = nanoseconds / 1000000L;
  if (nanoseconds % 1000000L != 0)
    milliseconds++;
  return (int)(seconds * 1000 + milliseconds);
}

static void terminate_helper(pid_t pid) {
  if (kill(-pid, SIGKILL) != 0 && errno != ESRCH)
    perror("mpd: terminate config helper");
  int status;
  while (waitpid(pid, &status, 0) < 0 && errno == EINTR) {
  }
}

static bool wait_for_helper(pid_t pid, int *status,
                            const struct timespec *deadline) {
  for (;;) {
    pid_t result = waitpid(pid, status, WNOHANG);
    if (result == pid)
      return true;
    if (result < 0) {
      if (errno == EINTR)
        continue;
      perror("mpd: wait for config helper");
      return false;
    }
    int remaining = milliseconds_until(deadline);
    if (remaining <= 0)
      return false;
    int pause = remaining < 20 ? remaining : 20;
    struct timespec delay = {.tv_sec = 0, .tv_nsec = (long)pause * 1000000L};
    while (nanosleep(&delay, &delay) < 0 && errno == EINTR) {
    }
  }
}

static bool parse_helper_output(char *output, size_t length,
                                const char *helper) {
  char *host = NULL;
  char *port = NULL;
  bool valid = true;

  if (memchr(output, '\0', length) != NULL)
    valid = false;
  output[length] = '\0';
  char *cursor = output;
  while (valid && *cursor != '\0') {
    char *line = cursor;
    char *newline = strchr(cursor, '\n');
    if (newline == NULL) {
      cursor += strlen(cursor);
    } else {
      *newline = '\0';
      cursor = newline + 1;
    }
    size_t line_length = strlen(line);
    while (line_length > 0U && line[line_length - 1U] == '\r')
      line[--line_length] = '\0';
    if (line_length == 0U)
      continue;

    char **destination = NULL;
    const char *value = NULL;
    if (strncmp(line, "MPD_HOST=", 9U) == 0) {
      destination = &host;
      value = line + 9;
    } else if (strncmp(line, "MPD_PORT=", 9U) == 0) {
      destination = &port;
      value = line + 9;
    } else {
      valid = false;
      continue;
    }
    if (*destination != NULL || !safe_helper_value(value) ||
        (destination == &port && !parse_helper_port(value))) {
      valid = false;
      continue;
    }
    *destination = strdup(value);
    if (*destination == NULL) {
      perror("mpd: store config helper output");
      valid = false;
    }
  }

  if (host == NULL || port == NULL)
    valid = false;
  if (!valid) {
    fprintf(stderr,
            "mpd: config helper '%s' must print exactly valid MPD_HOST and "
            "MPD_PORT assignments\n",
            helper);
  } else if (setenv("MPD_HOST", host, 1) != 0 ||
             setenv("MPD_PORT", port, 1) != 0) {
    perror("mpd: apply config helper output");
    valid = false;
  }

  free(host);
  free(port);
  return valid;
}

static bool collect_helper_output(int descriptor, pid_t pid, const char *helper,
                                  unsigned timeout_seconds) {
  int flags = fcntl(descriptor, F_GETFL);
  if (flags < 0 || fcntl(descriptor, F_SETFL, flags | O_NONBLOCK) != 0) {
    perror("mpd: configure config helper output");
    close(descriptor);
    terminate_helper(pid);
    return false;
  }

  struct timespec deadline;
  if (!monotonic_now(&deadline)) {
    close(descriptor);
    terminate_helper(pid);
    return false;
  }
  deadline.tv_sec += (time_t)timeout_seconds;

  char output[4098U];
  size_t length = 0U;
  bool overflow = false;
  bool complete = false;
  while (!complete) {
    char discard[1024U];
    void *destination = overflow ? (void *)discard : (void *)(output + length);
    size_t available = overflow ? sizeof(discard) : 4097U - length;
    ssize_t count = read(descriptor, destination, available);
    if (count > 0) {
      if (!overflow) {
        length += (size_t)count;
        if (length > 4096U)
          overflow = true;
      }
      continue;
    }
    if (count == 0) {
      complete = true;
      break;
    }
    if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) {
      perror("mpd: read config helper output");
      close(descriptor);
      terminate_helper(pid);
      return false;
    }
    if (errno == EINTR)
      continue;

    int remaining = milliseconds_until(&deadline);
    if (remaining <= 0)
      break;
    struct pollfd poll_descriptor = {.fd = descriptor, .events = POLLIN};
    int result;
    do {
      result = poll(&poll_descriptor, 1U, remaining);
    } while (result < 0 && errno == EINTR);
    if (result < 0) {
      perror("mpd: poll config helper output");
      close(descriptor);
      terminate_helper(pid);
      return false;
    }
    if (result == 0)
      break;
  }
  if (close(descriptor) != 0)
    perror("mpd: close config helper output");

  int status = 0;
  if (!complete || !wait_for_helper(pid, &status, &deadline)) {
    fprintf(stderr, "mpd: config helper '%s' timed out after %u seconds\n",
            helper, timeout_seconds);
    terminate_helper(pid);
    return false;
  }
  if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
    fprintf(stderr, "mpd: config helper '%s' exited unsuccessfully\n", helper);
    return false;
  }
  if (overflow) {
    fprintf(stderr, "mpd: config helper '%s' output exceeds 4096 bytes\n",
            helper);
    return false;
  }
  return parse_helper_output(output, length, helper);
}

static bool run_profile_helper(const char *helper) {
  unsigned timeout_seconds = helper_timeout_seconds();
  if (timeout_seconds == 0U)
    return false;
  int descriptors[2];
  if (pipe(descriptors) != 0) {
    perror("mpd: create config helper pipe");
    return false;
  }

  posix_spawn_file_actions_t actions;
  posix_spawnattr_t attributes;
  int error = posix_spawn_file_actions_init(&actions);
  bool actions_initialized = error == 0;
  bool attributes_initialized = false;
  if (error == 0)
    error = posix_spawn_file_actions_addclose(&actions, descriptors[0]);
  if (error == 0)
    error = posix_spawn_file_actions_adddup2(&actions, descriptors[1],
                                             STDOUT_FILENO);
  if (error == 0)
    error = posix_spawn_file_actions_addclose(&actions, descriptors[1]);
  if (error == 0) {
    error = posix_spawnattr_init(&attributes);
    attributes_initialized = error == 0;
  }
  if (error == 0)
    error = posix_spawnattr_setflags(&attributes, POSIX_SPAWN_SETPGROUP);
  if (error == 0)
    error = posix_spawnattr_setpgroup(&attributes, 0);
  if (error != 0) {
    fprintf(stderr, "mpd: prepare config helper: %s\n", strerror(error));
    if (actions_initialized) {
      int destroy_error = posix_spawn_file_actions_destroy(&actions);
      if (destroy_error != 0)
        fprintf(stderr, "mpd: release config helper actions: %s\n",
                strerror(destroy_error));
    }
    if (attributes_initialized) {
      int destroy_error = posix_spawnattr_destroy(&attributes);
      if (destroy_error != 0)
        fprintf(stderr, "mpd: release config helper attributes: %s\n",
                strerror(destroy_error));
    }
    close(descriptors[0]);
    close(descriptors[1]);
    return false;
  }

  pid_t pid;
  char *arguments[] = {(char *)helper, NULL};
  error = posix_spawn(&pid, helper, &actions, &attributes, arguments, environ);
  int destroy_error = posix_spawn_file_actions_destroy(&actions);
  if (destroy_error != 0)
    fprintf(stderr, "mpd: release config helper actions: %s\n",
            strerror(destroy_error));
  destroy_error = posix_spawnattr_destroy(&attributes);
  if (destroy_error != 0)
    fprintf(stderr, "mpd: release config helper attributes: %s\n",
            strerror(destroy_error));
  if (error != 0) {
    fprintf(stderr, "mpd: start config helper '%s': %s\n", helper,
            strerror(error));
    close(descriptors[0]);
    close(descriptors[1]);
    return false;
  }

  close(descriptors[1]);
  return collect_helper_output(descriptors[0], pid, helper, timeout_seconds);
}

static bool resolve_profile_helper(void) {
  if (profile_helper_state != HELPER_UNRESOLVED)
    return profile_helper_state == HELPER_READY;

  const char *configured = getenv("MPD_CONFIG_HELPER");
  if (configured != NULL &&
      (*configured == '\0' || strcmp(configured, "off") == 0)) {
    profile_helper_state = HELPER_READY;
    return true;
  }

  char *default_helper = NULL;
  const char *helper = configured;
  if (helper == NULL) {
    const char *home = getenv("HOME");
    if (home == NULL || *home == '\0') {
      profile_helper_state = HELPER_READY;
      return true;
    }
    size_t home_length = strlen(home);
    if (home_length > SIZE_MAX - sizeof("/bin/amen")) {
      fprintf(stderr, "mpd: HOME is too long\n");
      profile_helper_state = HELPER_FAILED;
      return false;
    }
    size_t length = home_length + sizeof("/bin/amen");
    default_helper = malloc(length);
    if (default_helper == NULL) {
      perror("mpd: config helper path");
      profile_helper_state = HELPER_FAILED;
      return false;
    }
    snprintf(default_helper, length, "%s/bin/amen", home);
    if (access(default_helper, X_OK) != 0) {
      free(default_helper);
      profile_helper_state = HELPER_READY;
      return true;
    }
    helper = default_helper;
  }

  bool valid = run_profile_helper(helper);
  free(default_helper);
  profile_helper_state = valid ? HELPER_READY : HELPER_FAILED;
  return valid;
}

struct mpd_connection *mt_connect_to(const char *host, unsigned port) {
  if (!resolve_profile_helper())
    return NULL;
  struct mpd_connection *connection = mpd_connection_new(host, port, 0);
  if (connection == NULL) {
    fprintf(stderr, "mpd: out of memory while creating connection\n");
    return NULL;
  }

  if (mpd_connection_get_error(connection) != MPD_ERROR_SUCCESS) {
    mt_report_error(connection, "connect");
    mpd_connection_free(connection);
    return NULL;
  }
  return connection;
}

struct mpd_connection *mt_connect(void) { return mt_connect_to(NULL, 0U); }

void mt_report_error(const struct mpd_connection *connection,
                     const char *context) {
  const char *message = connection == NULL
                            ? "unknown MPD error"
                            : mpd_connection_get_error_message(connection);
  fprintf(stderr, "mpd: %s: %s\n", context, message);
}

void mt_strvec_init(struct mt_strvec *vec) {
  vec->items = NULL;
  vec->len = 0;
  vec->cap = 0;
}

void mt_strvec_clear(struct mt_strvec *vec) {
  for (size_t i = 0; i < vec->len; i++)
    free(vec->items[i]);
  free(vec->items);
  mt_strvec_init(vec);
}

bool mt_strvec_push_n(struct mt_strvec *vec, const char *value, size_t length) {
  if (vec->len == vec->cap) {
    size_t cap = vec->cap == 0 ? 16U : vec->cap * 2U;
    if (cap < vec->cap || cap > SIZE_MAX / sizeof(*vec->items)) {
      errno = ENOMEM;
      return false;
    }
    char **items = realloc(vec->items, cap * sizeof(*items));
    if (items == NULL)
      return false;
    vec->items = items;
    vec->cap = cap;
  }

  if (length == SIZE_MAX) {
    errno = ENOMEM;
    return false;
  }
  char *copy = malloc(length + 1U);
  if (copy == NULL)
    return false;
  memcpy(copy, value, length);
  copy[length] = '\0';
  vec->items[vec->len] = copy;
  vec->len++;
  return true;
}

bool mt_strvec_push(struct mt_strvec *vec, const char *value) {
  return mt_strvec_push_n(vec, value, strlen(value));
}

bool mt_read_lines(FILE *input, struct mt_strvec *lines) {
  char *line = NULL;
  size_t capacity = 0;
  ssize_t length;

  while ((length = getline(&line, &capacity, input)) >= 0) {
    while (length > 0 && (line[(size_t)length - 1U] == '\n' ||
                          line[(size_t)length - 1U] == '\r'))
      line[--length] = '\0';
    if (length == 0 || line[0] == '#')
      continue;
    if (!mt_strvec_push(lines, line)) {
      perror("mpd: storing input line");
      free(line);
      return false;
    }
  }

  free(line);
  if (ferror(input)) {
    perror("mpd: reading input");
    return false;
  }
  return true;
}

FILE *mt_open_input(const char *path, bool *must_close) {
  if (path == NULL || strcmp(path, "-") == 0) {
    *must_close = false;
    return stdin;
  }

  FILE *input = fopen(path, "r");
  if (input == NULL)
    perror(path);
  *must_close = input != NULL;
  return input;
}

static bool finish_list(struct mpd_connection *connection,
                        const char *context) {
  if (!mpd_command_list_end(connection) || !mpd_response_finish(connection)) {
    mt_report_error(connection, context);
    return false;
  }
  return true;
}

bool mt_add_queue(struct mpd_connection *connection,
                  const struct mt_strvec *tracks, bool verbose) {
  for (size_t start = 0; start < tracks->len; start += MPD_TOOLS_BATCH_SIZE) {
    size_t end = start + MPD_TOOLS_BATCH_SIZE;
    if (end > tracks->len)
      end = tracks->len;
    if (!mpd_command_list_begin(connection, false)) {
      mt_report_error(connection, "begin add command list");
      return false;
    }
    for (size_t i = start; i < end; i++) {
      if (!mpd_send_add(connection, tracks->items[i])) {
        mt_report_error(connection, "queue add");
        return false;
      }
    }
    if (!finish_list(connection, "add tracks")) {
      fprintf(stderr, "mpd: failed input batch %zu..%zu\n", start + 1U, end);
      return false;
    }
    if (verbose) {
      for (size_t i = start; i < end; i++)
        printf("Added: %s\n", tracks->items[i]);
    }
  }
  return true;
}

bool mt_insert_queue(struct mpd_connection *connection,
                     const struct mt_strvec *tracks, unsigned position,
                     bool verbose) {
  size_t available = (size_t)UINT_MAX - (size_t)position + 1U;
  if (tracks->len > available) {
    fprintf(stderr, "mpd: too many tracks for the requested queue position\n");
    return false;
  }
  size_t inserted = 0;
  while (inserted < tracks->len) {
    size_t end = inserted + MPD_TOOLS_BATCH_SIZE;
    if (end > tracks->len)
      end = tracks->len;
    if (!mpd_command_list_begin(connection, false)) {
      mt_report_error(connection, "begin insert command list");
      return false;
    }
    for (size_t i = inserted; i < end; i++) {
      if (i - inserted > UINT_MAX - position ||
          !mpd_send_add_id_to(connection, tracks->items[i],
                              position + (unsigned)(i - inserted))) {
        mt_report_error(connection, "queue insert");
        return false;
      }
    }
    if (!finish_list(connection, "insert tracks"))
      return false;
    if (end < tracks->len)
      position += (unsigned)(end - inserted);
    if (verbose) {
      for (size_t i = inserted; i < end; i++)
        printf("Inserted: %s\n", tracks->items[i]);
    }
    inserted = end;
  }
  return true;
}

bool mt_add_playlist(struct mpd_connection *connection, const char *playlist,
                     const struct mt_strvec *tracks, bool verbose) {
  for (size_t start = 0; start < tracks->len; start += MPD_TOOLS_BATCH_SIZE) {
    size_t end = start + MPD_TOOLS_BATCH_SIZE;
    if (end > tracks->len)
      end = tracks->len;
    if (!mpd_command_list_begin(connection, false)) {
      mt_report_error(connection, "begin playlist command list");
      return false;
    }
    for (size_t i = start; i < end; i++) {
      if (!mpd_send_playlist_add(connection, playlist, tracks->items[i])) {
        mt_report_error(connection, "playlist add");
        return false;
      }
    }
    if (!finish_list(connection, "add playlist tracks"))
      return false;
    if (verbose) {
      for (size_t i = start; i < end; i++)
        printf("Added to %s: %s\n", playlist, tracks->items[i]);
    }
  }
  return true;
}

static bool add_stream(struct mpd_connection *connection, const char *playlist,
                       FILE *input, bool verbose, size_t *count) {
  struct mt_strvec batch;
  mt_strvec_init(&batch);
  char *line = NULL;
  size_t capacity = 0U;
  bool ok = true;
  *count = 0U;

  while (ok) {
    ssize_t length = getline(&line, &capacity, input);
    if (length < 0)
      break;
    while (length > 0 && (line[(size_t)length - 1U] == '\n' ||
                          line[(size_t)length - 1U] == '\r'))
      line[--length] = '\0';
    if (length == 0 || line[0] == '#')
      continue;
    if (!mt_strvec_push(&batch, line)) {
      perror("mpd: storing input line");
      ok = false;
    }
    if (ok && batch.len == MPD_TOOLS_BATCH_SIZE) {
      ok = playlist == NULL
               ? mt_add_queue(connection, &batch, verbose)
               : mt_add_playlist(connection, playlist, &batch, verbose);
      if (ok)
        *count += batch.len;
      mt_strvec_clear(&batch);
      mt_strvec_init(&batch);
    }
  }
  if (ok && ferror(input)) {
    perror("mpd: reading input");
    ok = false;
  }
  if (ok && batch.len > 0U) {
    ok = playlist == NULL
             ? mt_add_queue(connection, &batch, verbose)
             : mt_add_playlist(connection, playlist, &batch, verbose);
    if (ok)
      *count += batch.len;
  }
  free(line);
  mt_strvec_clear(&batch);
  return ok;
}

bool mt_add_queue_stream(struct mpd_connection *connection, FILE *input,
                         bool verbose, size_t *count) {
  return add_stream(connection, NULL, input, verbose, count);
}

bool mt_add_playlist_stream(struct mpd_connection *connection,
                            const char *playlist, FILE *input, bool verbose,
                            size_t *count) {
  return add_stream(connection, playlist, input, verbose, count);
}

void mt_player_state_clear(struct mt_player_state *state) {
  free(state->current_uri);
  memset(state, 0, sizeof(*state));
  state->song_pos = UINT_MAX;
  state->song_id = UINT_MAX;
}

bool mt_get_player_state(struct mpd_connection *connection,
                         struct mt_player_state *state) {
  for (unsigned attempt = 0U; attempt < PLAYER_SNAPSHOT_RETRIES; attempt++) {
    memset(state, 0, sizeof(*state));
    state->song_pos = UINT_MAX;
    state->song_id = UINT_MAX;

    struct mpd_status *status = mpd_run_status(connection);
    if (status == NULL) {
      mt_report_error(connection, "get status");
      return false;
    }
    state->state = mpd_status_get_state(status);
    state->queue_version = mpd_status_get_queue_version(status);
    state->queue_length = mpd_status_get_queue_length(status);
    int song_pos = mpd_status_get_song_pos(status);
    int song_id = mpd_status_get_song_id(status);
    if (song_pos >= 0)
      state->song_pos = (unsigned)song_pos;
    if (song_id >= 0)
      state->song_id = (unsigned)song_id;
    mpd_status_free(status);

    if (state->song_id == UINT_MAX)
      return true;

    struct mpd_song *song = mpd_run_current_song(connection);
    if (song == NULL) {
      if (mpd_connection_get_error(connection) != MPD_ERROR_SUCCESS) {
        mt_report_error(connection, "get current song");
        return false;
      }
      continue;
    }
    bool consistent = mpd_song_get_id(song) == state->song_id &&
                      mpd_song_get_pos(song) == state->song_pos;
    const char *uri = mpd_song_get_uri(song);
    bool has_uri = uri != NULL;
    if (consistent && has_uri)
      state->current_uri = strdup(uri);
    mpd_song_free(song);
    if (consistent && has_uri && state->current_uri == NULL) {
      perror("mpd: current song");
      return false;
    }
    if (consistent)
      return true;
  }
  fprintf(stderr, "mpd: player changed repeatedly while reading its state\n");
  return false;
}

static bool receive_song_uris(struct mpd_connection *connection,
                              struct mt_strvec *tracks) {
  struct mpd_entity *entity;
  while ((entity = mpd_recv_entity(connection)) != NULL) {
    if (mpd_entity_get_type(entity) == MPD_ENTITY_TYPE_SONG) {
      const struct mpd_song *song = mpd_entity_get_song(entity);
      const char *uri = mpd_song_get_uri(song);
      if (uri != NULL && !mt_strvec_push(tracks, uri)) {
        mpd_entity_free(entity);
        perror("mpd: storing queue");
        return false;
      }
    }
    mpd_entity_free(entity);
  }
  if (!mpd_response_finish(connection)) {
    mt_report_error(connection, "receive song list");
    return false;
  }
  return true;
}

bool mt_read_queue(struct mpd_connection *connection,
                   struct mt_strvec *tracks) {
  if (!mpd_send_list_queue_meta(connection)) {
    mt_report_error(connection, "list queue");
    return false;
  }
  return receive_song_uris(connection, tracks);
}

bool mt_read_playlist(struct mpd_connection *connection, const char *playlist,
                      struct mt_strvec *tracks) {
  if (!mpd_send_list_playlist(connection, playlist)) {
    mt_report_error(connection, "list stored playlist");
    return false;
  }
  return receive_song_uris(connection, tracks);
}

enum mt_state_match mt_player_state_is(struct mpd_connection *connection,
                                       unsigned expected_version,
                                       unsigned expected_song_id) {
  struct mpd_status *status = mpd_run_status(connection);
  if (status == NULL) {
    mt_report_error(connection, "check player state");
    return MT_STATE_ERROR;
  }
  int song_id = mpd_status_get_song_id(status);
  bool song_matches =
      expected_song_id == UINT_MAX
          ? song_id < 0
          : song_id >= 0 && (unsigned)song_id == expected_song_id;
  bool matches =
      mpd_status_get_queue_version(status) == expected_version && song_matches;
  mpd_status_free(status);
  return matches ? MT_STATE_MATCH : MT_STATE_CHANGED;
}

static size_t first_uri(const struct mt_strvec *tracks, const char *uri) {
  if (uri == NULL)
    return SIZE_MAX;
  for (size_t i = 0; i < tracks->len; i++) {
    if (strcmp(tracks->items[i], uri) == 0)
      return i;
  }
  return SIZE_MAX;
}

static bool add_queue_skipping(struct mpd_connection *connection,
                               const struct mt_strvec *tracks, size_t skip) {
  size_t index = 0U;
  while (index < tracks->len) {
    while (index < tracks->len && index == skip)
      index++;
    if (index == tracks->len)
      break;

    if (!mpd_command_list_begin(connection, false)) {
      mt_report_error(connection, "begin replacement add list");
      return false;
    }
    size_t sent = 0U;
    while (index < tracks->len && sent < MPD_TOOLS_BATCH_SIZE) {
      if (index != skip) {
        if (!mpd_send_add(connection, tracks->items[index])) {
          mt_report_error(connection, "add replacement track");
          return false;
        }
        sent++;
      }
      index++;
    }
    if (!finish_list(connection, "add replacement tracks"))
      return false;
  }
  return true;
}

static bool restore_queue_snapshot(const struct mt_strvec *tracks,
                                   const struct mt_player_state *state) {
  struct mpd_connection *connection = mt_connect();
  if (connection == NULL)
    return false;
  bool ok = mpd_run_clear(connection);
  if (!ok)
    mt_report_error(connection, "rollback: clear partial queue");
  if (ok)
    ok = mt_add_queue(connection, tracks, false);
  if (ok && tracks->len > 0U && state->song_pos < tracks->len &&
      (state->state == MPD_STATE_PLAY || state->state == MPD_STATE_PAUSE)) {
    ok = mpd_run_play_pos(connection, state->song_pos);
    if (!ok) {
      mt_report_error(connection, "rollback: restore playback position");
    } else if (state->state == MPD_STATE_PAUSE) {
      ok = mpd_run_pause(connection, true);
      if (!ok)
        mt_report_error(connection, "rollback: restore paused state");
    }
  }
  mpd_connection_free(connection);
  return ok;
}

bool mt_replace_queue(struct mpd_connection *connection,
                      const struct mt_strvec *tracks, unsigned expected_version,
                      bool force) {
  struct mt_player_state state;
  struct mt_strvec original;
  mt_strvec_init(&original);
  bool snapshot_ready = false;
  bool state_changed = false;
  for (unsigned attempt = 0U; attempt < PLAYER_SNAPSHOT_RETRIES; attempt++) {
    if (!mt_get_player_state(connection, &state))
      break;
    if (!force && expected_version != UINT_MAX &&
        state.queue_version != expected_version) {
      fprintf(stderr, "mpd: queue changed while it was being edited; use "
                      "--force to replace it anyway\n");
      mt_player_state_clear(&state);
      break;
    }
    if (!mt_read_queue(connection, &original)) {
      mt_player_state_clear(&state);
      break;
    }
    enum mt_state_match match =
        mt_player_state_is(connection, state.queue_version, state.song_id);
    if (match == MT_STATE_MATCH) {
      snapshot_ready = true;
      break;
    }
    if (match == MT_STATE_CHANGED)
      state_changed = true;
    mt_player_state_clear(&state);
    mt_strvec_clear(&original);
    mt_strvec_init(&original);
    if (match == MT_STATE_ERROR)
      break;
  }
  if (!snapshot_ready) {
    if (state_changed)
      fprintf(stderr, "mpd: player changed repeatedly before replacement\n");
    mt_strvec_clear(&original);
    return false;
  }

  size_t keep = first_uri(tracks, state.current_uri);
  bool can_keep = keep != SIZE_MAX && state.song_pos != UINT_MAX &&
                  state.song_pos < state.queue_length;
  bool ok = true;
  bool mutation_started = false;

  if (can_keep) {
    bool needs_trim =
        state.song_pos > 0U || state.song_pos + 1U < state.queue_length;
    if (needs_trim) {
      mutation_started = true;
      if (!mpd_command_list_begin(connection, false)) {
        mt_report_error(connection, "begin queue trim");
        ok = false;
      }
      if (ok && state.song_pos + 1U < state.queue_length &&
          !mpd_send_delete_range(connection, state.song_pos + 1U,
                                 state.queue_length)) {
        mt_report_error(connection, "delete queue suffix");
        ok = false;
      }
      if (ok && state.song_pos > 0U &&
          !mpd_send_delete_range(connection, 0U, state.song_pos)) {
        mt_report_error(connection, "delete queue prefix");
        ok = false;
      }
      if (ok)
        ok = finish_list(connection, "trim queue around current song");
    }
    if (ok) {
      mutation_started = true;
      ok = add_queue_skipping(connection, tracks, keep);
    }
    if (ok && keep > 0U && !mpd_run_move(connection, 0U, (unsigned)keep)) {
      mt_report_error(connection, "restore current queue position");
      ok = false;
    }
  } else {
    mutation_started = true;
    if (!mpd_run_clear(connection)) {
      mt_report_error(connection, "clear queue");
      ok = false;
    }
    if (ok)
      ok = mt_add_queue(connection, tracks, false);
    if (ok && tracks->len > 0U &&
        (state.state == MPD_STATE_PLAY || state.state == MPD_STATE_PAUSE)) {
      if (!mpd_run_play_pos(connection, 0U)) {
        mt_report_error(connection, "restart playback");
        ok = false;
      } else if (state.state == MPD_STATE_PAUSE &&
                 !mpd_run_pause(connection, true)) {
        mt_report_error(connection, "restore paused state");
        ok = false;
      }
    }
  }

  if (!ok && mutation_started) {
    fprintf(stderr, "mpd: replacement failed; restoring the previous queue\n");
    if (!restore_queue_snapshot(&original, &state))
      fprintf(stderr, "mpd: rollback failed; the queue may be partial\n");
  }

  mt_player_state_clear(&state);
  mt_strvec_clear(&original);
  return ok;
}

static bool same_tracks(const struct mt_strvec *left,
                        const struct mt_strvec *right) {
  if (left->len != right->len)
    return false;
  for (size_t i = 0U; i < left->len; i++) {
    if (strcmp(left->items[i], right->items[i]) != 0)
      return false;
  }
  return true;
}

static unsigned long playlist_name_sequence;

static void temporary_playlist_name(char *buffer, size_t size,
                                    const char *purpose) {
  playlist_name_sequence++;
  struct timespec now = {0};
  if (clock_gettime(CLOCK_REALTIME, &now) != 0)
    now.tv_nsec = (long)playlist_name_sequence;
  snprintf(buffer, size, "mpd-tools-%ld-%lld-%ld-%lu-%s", (long)getpid(),
           (long long)now.tv_sec, now.tv_nsec, playlist_name_sequence, purpose);
}

static void remove_temporary_playlist(const char *playlist) {
  struct mpd_connection *cleanup = mt_connect();
  if (cleanup == NULL)
    return;
  if (!mpd_run_rm(cleanup, playlist) &&
      mpd_connection_get_error(cleanup) != MPD_ERROR_SERVER)
    mt_report_error(cleanup, "remove temporary playlist");
  mpd_connection_free(cleanup);
}

bool mt_replace_playlist(struct mpd_connection *connection,
                         const char *playlist, const struct mt_strvec *tracks,
                         const struct mt_strvec *expected, bool force) {
  if (tracks->len == 0U) {
    if (!force) {
      struct mt_strvec current;
      mt_strvec_init(&current);
      bool read_ok = mt_read_playlist(connection, playlist, &current);
      bool unchanged = read_ok && same_tracks(expected, &current);
      mt_strvec_clear(&current);
      if (!read_ok)
        return false;
      if (!unchanged) {
        fprintf(stderr, "mpd: stored playlist changed while it was being "
                        "edited; use --force to replace it anyway\n");
        return false;
      }
    }
    if (!mpd_run_playlist_clear(connection, playlist)) {
      mt_report_error(connection, "clear stored playlist");
      return false;
    }
    return true;
  }

  char staged[128U];
  char backup[128U];
  temporary_playlist_name(staged, sizeof(staged), "new");
  temporary_playlist_name(backup, sizeof(backup), "old");
  if (!mt_add_playlist(connection, staged, tracks, false)) {
    remove_temporary_playlist(staged);
    return false;
  }

  if (!force) {
    struct mt_strvec current;
    mt_strvec_init(&current);
    bool read_ok = mt_read_playlist(connection, playlist, &current);
    bool unchanged = read_ok && same_tracks(expected, &current);
    mt_strvec_clear(&current);
    if (!read_ok) {
      remove_temporary_playlist(staged);
      return false;
    }
    if (!unchanged) {
      fprintf(stderr, "mpd: stored playlist changed while it was being "
                      "edited; use --force to replace it anyway\n");
      remove_temporary_playlist(staged);
      return false;
    }
  }

  if (!mpd_run_rename(connection, playlist, backup)) {
    mt_report_error(connection, "move old stored playlist aside");
    remove_temporary_playlist(staged);
    return false;
  }
  if (!mpd_run_rename(connection, staged, playlist)) {
    mt_report_error(connection, "install staged stored playlist");
    struct mpd_connection *rollback = mt_connect();
    if (rollback == NULL || !mpd_run_rename(rollback, backup, playlist))
      fprintf(stderr,
              "mpd: playlist rollback failed; '%s' contains the "
              "backup\n",
              backup);
    if (rollback != NULL)
      mpd_connection_free(rollback);
    remove_temporary_playlist(staged);
    return false;
  }
  if (!mpd_run_rm(connection, backup)) {
    mt_report_error(connection, "remove stored playlist backup");
    fprintf(stderr, "mpd: replacement succeeded, but backup '%s' remains\n",
            backup);
    return false;
  }
  return true;
}

static bool run_editor(const char *path) {
  const char *editor = getenv("VISUAL");
  if (editor == NULL || *editor == '\0')
    editor = getenv("EDITOR");
  if (editor == NULL || *editor == '\0')
    editor = "vi";

  wordexp_t words;
  int result = wordexp(editor, &words, WRDE_NOCMD);
  if (result != 0 || words.we_wordc == 0U) {
    fprintf(stderr, "mpd: invalid editor command\n");
    if (result == 0)
      wordfree(&words);
    return false;
  }

  char **args = calloc(words.we_wordc + 2U, sizeof(*args));
  if (args == NULL) {
    perror("mpd: editor arguments");
    wordfree(&words);
    return false;
  }
  for (size_t i = 0; i < words.we_wordc; i++)
    args[i] = words.we_wordv[i];
  args[words.we_wordc] = (char *)path;

  pid_t pid = fork();
  if (pid == 0) {
    execvp(args[0], args);
    perror(args[0]);
    _exit(127);
  }
  if (pid < 0) {
    perror("mpd: fork editor");
    free(args);
    wordfree(&words);
    return false;
  }

  int status;
  while (waitpid(pid, &status, 0) < 0) {
    if (errno != EINTR) {
      perror("mpd: wait for editor");
      free(args);
      wordfree(&words);
      return false;
    }
  }
  free(args);
  wordfree(&words);
  if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
    fprintf(stderr, "mpd: editor exited unsuccessfully\n");
    return false;
  }
  return true;
}

static char *editor_file_template(void) {
  const char *directory = getenv("TMPDIR");
  if (directory == NULL || *directory == '\0')
    directory = "/tmp";
  size_t directory_length = strlen(directory);
  bool needs_slash = directory[directory_length - 1U] != '/';
  const char suffix[] = "mpd_tools_XXXXXX";
  if (directory_length > SIZE_MAX - sizeof(suffix) - (size_t)needs_slash) {
    errno = ENAMETOOLONG;
    return NULL;
  }
  size_t length = directory_length + (size_t)needs_slash + sizeof(suffix);
  char *path = malloc(length);
  if (path == NULL)
    return NULL;
  snprintf(path, length, "%s%s%s", directory, needs_slash ? "/" : "", suffix);
  return path;
}

bool mt_edit_lines(struct mt_strvec *lines) {
  char *path = editor_file_template();
  if (path == NULL) {
    perror("mpd: create editor file path");
    return false;
  }
  int fd = mkstemp(path);
  if (fd < 0) {
    perror("mpd: create editor file");
    free(path);
    return false;
  }
  FILE *file = fdopen(fd, "w");
  if (file == NULL) {
    perror("mpd: open editor file");
    close(fd);
    unlink(path);
    free(path);
    return false;
  }
  bool ok = true;
  for (size_t i = 0; i < lines->len; i++) {
    if (fprintf(file, "%s\n", lines->items[i]) < 0) {
      perror("mpd: write editor file");
      ok = false;
      break;
    }
  }
  if (fclose(file) != 0) {
    perror("mpd: close editor file");
    ok = false;
  }

  if (ok)
    ok = run_editor(path);
  if (ok) {
    int read_fd = open(path, O_RDONLY | O_NOFOLLOW);
    if (read_fd < 0) {
      perror("mpd: reopen editor file");
      ok = false;
    } else {
      file = fdopen(read_fd, "r");
      if (file == NULL) {
        perror("mpd: read editor file");
        close(read_fd);
        ok = false;
      } else {
        struct mt_strvec edited;
        mt_strvec_init(&edited);
        ok = mt_read_lines(file, &edited);
        if (fclose(file) != 0) {
          perror("mpd: close edited file");
          ok = false;
        }
        if (ok) {
          mt_strvec_clear(lines);
          *lines = edited;
        } else {
          mt_strvec_clear(&edited);
        }
      }
    }
  }

  if (unlink(path) != 0)
    perror("mpd: remove editor file");
  free(path);
  return ok;
}

bool mt_parse_size(const char *text, size_t *value) {
  if (text == NULL || *text == '\0' || *text == '-')
    return false;
  errno = 0;
  char *end;
  unsigned long long parsed = strtoull(text, &end, 10);
  if (errno != 0 || *end != '\0' || parsed > SIZE_MAX)
    return false;
  *value = (size_t)parsed;
  return true;
}