#include "core/window.h"

#include "base/memory.h"
#include "core/types.h"

window_layer_type_t window_classify_layer(const window_layer_props_t *props) {
  for (size_t i = 0; i < props->type_count; ++i) {
    window_type_t type = props->types[i];
    if (type == ZDWM_WINDOW_TYPE_NOTIFICATION) return ZDWM_WINDOW_LAYER_OVERLAY;
  }

  for (size_t i = 0; i < props->state_count; ++i) {
    window_state_t state = props->states[i];
    if (state == ZDWM_WINDOW_STATE_ABOVE) return ZDWM_WINDOW_LAYER_TOP;
  }

  return ZDWM_WINDOW_LAYER_NORMAL;
}

void window_layer_props_cleanup(window_layer_props_t *props) {
  if (!props) return;

  p_delete(&props->types);
  props->type_count = 0;
  p_delete(&props->states);
  props->state_count = 0;
}

void window_metadata_cleanup(window_metadata_t *metadata) {
  if (!metadata) return;

  p_delete(&metadata->title);
  p_delete(&metadata->app_id);
  p_delete(&metadata->role);
  p_delete(&metadata->class_name);
  p_delete(&metadata->instance_name);
}

void window_set_fullscreen(window_t *window, bool fullscreen) {
  window->fullscreen = fullscreen;
}

void window_set_maximized(window_t *window, bool maximized) {
  window->maximized = maximized;
}

void window_set_minimized(window_t *window, bool minimized) {
  window->minimized = minimized;
}

void window_set_floating(window_t *window, bool floating) {
  if (!floating && (window_should_fix_size(window) || window->sticky)) return;

  if (floating == window->floating) return;

  window->floating = floating;
  if (floating) window_set_frame_rect(window, window->float_rect);
  else window_set_float_rect(window, window->frame_rect);
}

void window_set_sticky(window_t *window, bool sticky) {
  window->sticky = sticky;
  if (sticky) window_set_floating(window, true);
}

void window_set_urgent(window_t *window, bool urgent) {
  window->urgent = urgent;
}

void window_set_skip_taskbar(window_t *window, bool skip_taskbar) {
  window->skip_taskbar = skip_taskbar;
}

void window_set_float_rect(window_t *window, rect_t rect) {
  window->float_rect = rect;
}

void window_set_frame_rect(window_t *window, rect_t rect) {
  window->frame_rect = rect;
}

void window_set_size_hint(window_t *window, zdwm_size_t min, zdwm_size_t max) {
  window->min_size = min;
  window->max_size = max;
  if (!window_should_fix_size(window)) return;

  auto rect = window->frame_rect;
  rect.width = min.width;
  rect.height = min.height;
  window_set_frame_rect(window, rect);
  window_set_floating(window, true);
}

void window_set_title(window_t *window, const char *title) {
  p_delete(&window->title);
  window->title = p_strdup_nullable(title);
}

void window_set_app_id(window_t *window, const char *app_id) {
  p_delete(&window->app_id);
  window->app_id = p_strdup_nullable(app_id);
}

void window_set_role(window_t *window, const char *role) {
  p_delete(&window->role);
  window->role = p_strdup_nullable(role);
}

void window_set_class(window_t *window, const char *class_name) {
  p_delete(&window->class_name);
  window->class_name = p_strdup_nullable(class_name);
}

void window_set_instance(window_t *window, const char *instance_name) {
  p_delete(&window->instance_name);
  window->instance_name = p_strdup_nullable(instance_name);
}

void window_set_border_width(window_t *window, uint32_t border_width) {
  window->border_width = border_width;
}

void window_take_metadata(
  window_t *window,
  window_metadata_t *metadata,
  uint32_t changed_fields
) {
  if (changed_fields & ZDWM_WINDOW_METADATA_CHANGE_TITLE) {
    p_take(&window->title, &metadata->title);
  }
  if (changed_fields & ZDWM_WINDOW_METADATA_CHANGE_APP_ID) {
    p_take(&window->app_id, &metadata->app_id);
  }
  if (changed_fields & ZDWM_WINDOW_METADATA_CHANGE_ROLE) {
    p_take(&window->role, &metadata->role);
  }
  if (changed_fields & ZDWM_WINDOW_METADATA_CHANGE_CLASS) {
    p_take(&window->class_name, &metadata->class_name);
  }
  if (changed_fields & ZDWM_WINDOW_METADATA_CHANGE_INSTANCE) {
    p_take(&window->instance_name, &metadata->instance_name);
  }
}

bool window_need_layout(const window_t *window) {
  if (window->floating) return false;

  if (window->fullscreen || window->maximized || window->minimized) {
    return false;
  }

  return true;
}

bool window_need_move(const window_t *window, int32_t x, int32_t y) {
  return window->frame_rect.x != x || window->frame_rect.y != y;
}

bool window_need_resize(const window_t *window, int32_t width, int32_t height) {
  return window->frame_rect.width != width ||
         window->frame_rect.height != height;
}

bool window_should_has_border(const window_t *window) {
  if (window->fullscreen || window->maximized) return false;
  return window->floating;
}

bool window_should_fix_size(const window_t *window) {
  auto max = window->max_size;
  auto min = window->min_size;
  return max.width == min.width && max.height == min.height;
}

bool window_can_resize(const window_t *window) {
  if (window->fullscreen || window->maximized) return false;
  if (window_should_fix_size(window)) return false;

  return true;
}