#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#define DEFAULT_LEN 8

struct DynArray {
  int* array;
  size_t capacity;
  size_t length;
};

struct SLNode {
  double data;
  struct SLNode * next;
};

void vivod_dynarray(struct DynArray d)
{
  for (unsigned int i = 0; i < d.length; i++)
  {
    printf("%i ", d.array[i]);
  }
  puts("");
  printf("capacity : %li\n", d.capacity);
  printf("length : %li\n", d.length);
  puts("");
}

void dynarray_init(struct DynArray* d)
{
  if (d->array == NULL)
  {
    d->array = (int*)malloc(DEFAULT_LEN * sizeof(int));
    if (d->array == NULL) free(d->array), exit(1);
    d->capacity = DEFAULT_LEN;
    d->length = 0;
  }
  vivod_dynarray(*d);
}

void dynarray_deinit(struct DynArray* d)
{
  free(d->array);
  d->capacity = 0;
  d->length = 0;
}

void dynarray_clear(struct DynArray* d)
{
  d->length = 0;
  vivod_dynarray(*d);
}

void dynarray_shrink_to_fit(struct DynArray* d)
{
  if (d->capacity > d->length)
  {
    int * new_array = (int*)realloc(d->array, d->length * sizeof(int));
    if (new_array == NULL) free(d->array), exit(1);
    else d->array = new_array;
    d->capacity = d->length;
  }
  vivod_dynarray(*d);
}

void dynarray_push_front(struct DynArray* d, int value)
{
  if (d->capacity == d->length)
  {
    int* new_array = (int*)realloc(d->array, (d->capacity + DEFAULT_LEN)* sizeof(int));
    if (new_array == NULL) free(d->array), exit(1);
    else d->array = new_array;
    d->capacity += DEFAULT_LEN;
  }
  for (unsigned int i = 0; i < d->length;i++)
  {
    d->array[d->length - i] = d->array[d->length - i - 1];
  }
  d->length++;
  d->array[0] = value;
  vivod_dynarray(*d);
}

void dynarray_pop_back(struct DynArray* d)
{
  d->length--;
  vivod_dynarray(*d);
}

void dynarray_main(struct DynArray* d, int value)
{
  dynarray_init(d);
  dynarray_push_front(d, value);
  dynarray_push_front(d, value + 15);
  dynarray_shrink_to_fit(d);
  dynarray_pop_back(d);
  dynarray_clear(d);
  dynarray_deinit(d);
  vivod_dynarray(*d);
}

void vivod_slnode(struct SLNode* d)
{
  struct SLNode* k = d;
  while (k!= NULL)
  {
    printf("%f ", k->data);
    k = k->next;
  }
  puts("");
}

struct SLNode* slnode_push_back(struct SLNode* d, double value)
{
  if (d == NULL)
  {
    struct SLNode* k = (struct SLNode*)malloc(sizeof(struct SLNode));
    if (k == NULL) free(d), exit(1);
    d = k;
    d->data = value;
    d->next = NULL;
  }
  else
  {
    struct SLNode* k = d;
    while (k->next != NULL)
    {
      k = k->next;
    }
    k->next = (struct SLNode*)malloc(sizeof(struct SLNode));
    if (k->next == NULL) free(d), exit(1);
    k->next->data = value;
    k->next->next = NULL;
  }
  vivod_slnode(d);
  return d;
}

struct SLNode* slnode_push_front(struct SLNode* d, double value)
{
  struct SLNode* k = (struct SLNode*)malloc(sizeof(struct SLNode));
  if (k == NULL) free(d), exit(1);
  if (d == NULL)
  {
    d = k;
    d->data = value;
    d->next = NULL;
  }
  else
  {
    k->next = d;
    k->data = value;
  }
  vivod_slnode(k);
  return k;
}


int slnode_size(struct SLNode* d)
{
  int count = 0;
  if (d != NULL)
  {
    count++;
    struct SLNode* k = d;
    while (k->next != NULL)
    {
      count++;
      k = k->next;
    }
  }
  return count;
}

void slnode_clear(struct SLNode* d)
{
  struct SLNode* k = d;
  while (k != NULL)
  {
    struct SLNode* next = k->next;
    free(k);
    k = next;
  }
}

int slnode_count_zero(struct SLNode* d)
{
  if (d == NULL) return 0;
  else
  {
    int count = 0;
    struct SLNode* k = d;
    while (k != NULL)
    {
      if (k->data < 0.001 && k->data > -0.001) count++;
      k = k->next;
    }
    return count;
  }
}

double slnode_max(struct SLNode* d)
{
  if (d == NULL) return NAN;
  struct SLNode* k = d;
  double max = k->data;
  k = k->next;
  while (k != NULL)
  {
    if (k->data > max)
    {
      max = k->data;
    }
    k = k->next;
  }
  return max;
}
void slnode_main(struct SLNode* d,int value)
{
  slnode_push_front(d, 0);
  slnode_push_front(d, 0);
  slnode_push_front(d, value);
  slnode_push_back(d, value + 3.141592);
  printf("size of array : %i\n", slnode_size(d));
  printf("zeros in array : %i\n", slnode_count_zero(d));
  printf("max el : %f\n",slnode_max(d));
  slnode_clear(d);
}

int main()
{
  char buff[DEFAULT_LEN * 4];

  struct DynArray Darr = { NULL,0,0 };
  struct SLNode* Slnode = NULL;

  for (;;)
  {
    puts("Enter command: ");
    fgets(buff, DEFAULT_LEN * 4, stdin);

    if (!strncmp(buff, "quit", 4)) break;
    if (!strncmp(buff, "dynarray_init", 13)) dynarray_init(&Darr);
    else if (!strncmp(buff, "dynarray_deinit", 15)) dynarray_deinit(&Darr);
    else if (!strncmp(buff, "dynarray_clear", 14)) dynarray_clear(&Darr);
    else if (!strncmp(buff, "dynarray_shrink_to_fit", 22)) dynarray_shrink_to_fit(&Darr);
    else if (!strncmp(buff, "dynarray_push_front", 19)) dynarray_push_front(&Darr,atoi(buff + 20));
    else if (!strncmp(buff, "dynarray_pop_back", 19)) dynarray_pop_back(&Darr);
    else if (!strncmp(buff, "dynarray_main", 13)) dynarray_main(&Darr,atoi(buff));

    else if (!strncmp(buff, "slnode_push_front", 17)) Slnode = slnode_push_front(Slnode,atof(buff+18));
    else if (!strncmp(buff, "slnode_push_back", 16)) Slnode = slnode_push_back(Slnode,atof(buff+17));
    else if (!strncmp(buff, "slnode_size", 11)) slnode_size(Slnode);
    else if (!strncmp(buff, "slnode_clear", 12)) slnode_clear(Slnode);
    else if (!strncmp(buff, "slnode_count_zero", 17)) slnode_count_zero(Slnode);
    else if (!strncmp(buff, "slnode_max", 10)) slnode_max(Slnode);
    else if (!strncmp(buff, "slnode_main", 11))
    {
      Slnode = slnode_push_front(Slnode, 0);
      Slnode = slnode_push_front(Slnode, 0);
      Slnode = slnode_push_front(Slnode, atof(buff + 12));
      Slnode = slnode_push_back(Slnode, atof(buff + 12) + 3.141592);
      printf("size of array : %i\n", slnode_size(Slnode));
      printf("zeros in array : %i\n", slnode_count_zero(Slnode));
      printf("max el : %f\n", slnode_max(Slnode));
      slnode_clear(Slnode);
    }

    else printf("Command is invalid. \nYou've entered : %s\a\n", buff);
  }
  return 0;
}