#include "devices/timer.h"
#include <debug.h>
#include <inttypes.h>
#include <round.h>
#include <stdio.h>
#include "devices/pit.h"
#include "threads/interrupt.h"
#include "threads/synch.h"
#include "threads/thread.h"

/* See [8254] for hardware details of the 8254 timer chip. */

#if TIMER_FREQ < 19
#error 8254 timer requires TIMER_FREQ >= 19
#endif
#if TIMER_FREQ > 1000
#error TIMER_FREQ <= 1000 recommended
#endif

/* Number of timer ticks since OS booted. */
static int64_t ticks;

/* Number of loops per timer tick.
   Initialized by timer_calibrate(). */
static unsigned loops_per_tick;

static intr_handler_func timer_interrupt;
static bool too_many_loops (unsigned loops);
static void busy_wait (int64_t loops);
static void real_time_sleep (int64_t num, int32_t denom);
static void real_time_delay (int64_t num, int32_t denom);

 //


/* Sets up the timer to interrupt TIMER_FREQ times per second,
   and registers the corresponding interrupt. */
void
timer_init (void)
{
  pit_configure_channel (0, 2, TIMER_FREQ);
  intr_register_ext (0x20, timer_interrupt, "8254 Timer");
}
struct sleeping_threads *head=NULL;
struct sleeping_threads *root=NULL;
struct sleeping_threads *root_temp=NULL;
int lavax=0;
int numOfProccess=0;
void Sleeping_threads_init (int priority, int64_t tickses, int64_t StartTimeSleeping)
{
  struct sleeping_threads *tmp=(struct sleeping_threads*)malloc(sizeof(struct sleeping_threads));
  tmp->sleeping_priority=priority;
  tmp->ticksForGetUp=tickses;
  tmp->startTimeSleep=StartTimeSleeping;
  tmp->next=head;
  root=tmp;
  head=tmp;
  numOfProccess++;
  Sleeping_threads_control();
}
void Sleeping_threads_control()
{
   printf("Main Process");
   printf("%d ", timer_elapsed (root->startTimeSleep));
   printf("%d  \n", root->ticksForGetUp);
  while (timer_elapsed (root->startTimeSleep) < root->ticksForGetUp)
  {
   // CheckForTurgetProc();
    if (numOfProccess>1)
    {
      if (timer_elapsed (root->next->startTimeSleep) < root->next->ticksForGetUp)
      {
        //struct thread *tur = thread_current ();
        //thread_unblock(root->next->proc); // разблокировать процесс
        //enum intr_level old_level;
        //old_level = intr_disable ();
        if (root->next->proc->status==THREAD_BLOCKED)
        {
          printf("This is blocked process\n");
        }
          //root->next->proc->status=THREAD_READY; // заблокировать роцесс
       // Sleeping_threads_block();
          //thread_yield();

        //intr_set_level (old_level);
        struct sleeping_threads *t;
        if (numOfProccess>2)
        {

          t=root->next;
          t->proc->sleep_ident=0;
         // printf("%s ", t->proc->name);
          root->next=t->next;

          free(t);


          //root_temp=root;
          numOfProccess--;
          //Sleeping_threads_print();
        }
        else
        {
          free(root->next);
          root->next=NULL;
          numOfProccess--;
        }
        InputReadyList(root->next->proc);

      }
    }
  }
}
void Sleeping_threads_add(int priority_1, int64_t tickses_1, int64_t StartTimeSleeping, struct thread *proces)
{
  struct sleeping_threads *tmp;
  tmp=root_temp;
  if (tmp->next==NULL || (tmp->ticksForGetUp<tickses_1 && tmp->next->ticksForGetUp>=tickses_1))
  {

    struct sleeping_threads *p=NULL;
    p=(struct sleeping_threads*)malloc(sizeof(struct sleeping_threads));
    p->sleeping_priority=priority_1;
    p->ticksForGetUp=tickses_1;
    p->startTimeSleep=StartTimeSleeping;
    p->proc=proces;
    proces->sleep_ident=1;
    //Sleeping_threads_block();
   // thread_yield();
    //printf("%s\n", p->proc->name);
    //thread_block();
    printf("Add sleeping process as: ");

    //thread_yield();
    if (tmp->next!=NULL)
    {
      printf("NOT LAST ELEM\n");
      p->next=tmp->next;
    }
    else
    {
      printf("LAST ELEM\n");
      p->next=NULL;
    }
    tmp->next=p;


    numOfProccess++;

    //root_temp=root;
    //Sleeping_threads_print();
    enum intr_level old_level;
    old_level = intr_disable ();

    proces->status=THREAD_BLOCKED; // заблокировать роцесс
    Sleeping_threads_block();

    intr_set_level (old_level);

  }
  else
  {
    root_temp=tmp->next;
    Sleeping_threads_add(priority_1, tickses_1, StartTimeSleeping, proces);
  }
}
void Sleeping_threads_print()
{
  //struct sleeping_threads *tmp=(struct sleeping_threads*)malloc(sizeof(struct sleeping_threads));
  if (root_temp!=NULL)
  {
    struct sleeping_threads *tmp;
    tmp=root_temp;
    printf("\n");
    printf("%s  ", tmp->proc->name);
    printf("Processe's prior=");
    printf("%d", tmp->sleeping_priority);
    printf(" Timing=");
    printf("%d\n", tmp->ticksForGetUp);
    printf("\n");
    root_temp=tmp->next;

    //numOfProccess--;
    Sleeping_threads_print();
  }
}


/*static void Sleeping_threads_init(void)
{
  printf("Init complete\n");
  t_user=malloc(sizeof(struct sleeping_threads));
  t_user->next=NULL;
  root_user=t_user->next;

}
static void Sleeping_threads_add(struct sleeping_threads *t, int64_t timing, int prior)
{
  struct sleeping_threads *temp, *p;
  temp=malloc(sizeof(struct sleeping_threads));
  t=malloc(sizeof(struct sleeping_threads));
  p=t->next;
  t->next=temp;
  temp->sleeping_priority=prior;
  temp->ticksForGetUp=timing;
  printf("Processe's prior=");
  printf("%d", temp->sleeping_priority);
  printf(" Timing=");
  printf("%d\n", temp->ticksForGetUp);
  temp->next=p;
  t_user=temp;
}
static void Search_Place_for_process(struct sleeping_threads *wt, int64_t timing_1, int prior_1)
{

  int64_t temp_time=timing_1;
  int temp_prior=prior_1;
  if (wt!=t_user)
  {
    printf("GO WAIT\n");
    if (timing_1>wt->ticksForGetUp)
    {
      printf("GO NEXT\n");
      wt=wt->next;
      Search_Place_for_process(wt, temp_time, temp_prior);
    }
    else
    {
      printf("INPUT BETWEEN\n");
      Sleeping_threads_add(wt, temp_time, temp_prior);
    }

  }
  else
  {
    printf("INPUT\n");
    Sleeping_threads_add(wt, temp_time, temp_prior);
  }


}*/

/* Calibrates loops_per_tick, used to implement brief delays. */
void
timer_calibrate (void)
{
  unsigned high_bit, test_bit;

  ASSERT (intr_get_level () == INTR_ON);
  printf ("Calibrating timer...  ");

  /* Approximate loops_per_tick as the largest power-of-two
     still less than one timer tick. */
  loops_per_tick = 1u << 10;
  while (!too_many_loops (loops_per_tick << 1))
    {
      loops_per_tick <<= 1;
      ASSERT (loops_per_tick != 0);
    }

  /* Refine the next 8 bits of loops_per_tick. */
  high_bit = loops_per_tick;
  for (test_bit = high_bit >> 1; test_bit != high_bit >> 10; test_bit >>= 1)
    if (!too_many_loops (high_bit | test_bit))
      loops_per_tick |= test_bit;

  printf ("%'"PRIu64" loops/s.\n", (uint64_t) loops_per_tick * TIMER_FREQ);
}

/* Returns the number of timer ticks since the OS booted. */
int64_t
timer_ticks (void)
{
  enum intr_level old_level = intr_disable ();
  int64_t t = ticks;
  intr_set_level (old_level);
  return t;
}

/* Returns the number of timer ticks elapsed since THEN, which
   should be a value once returned by timer_ticks(). */
int64_t
timer_elapsed (int64_t then)
{
  return timer_ticks () - then;
}

/* Sleeps for approximately TICKS timer ticks.  Interrupts must
   be turned on. */
void
timer_sleep (int64_t ticks)
{

  int64_t start = timer_ticks ();
    //printf("Go to sleep_L");
    //printf("%s\n",thread_current ()->name );
  ASSERT (intr_get_level () == INTR_ON);

  //Sleeping_threads_add(root, ticks, thread_current()->priority);
  if (lavax==0)
  {
    lavax=1;
    Sleeping_threads_init(thread_current()->priority, ticks, start);
  }
  else
  {
    printf("NEW PROCESS WANT TO SLEEP\n");
    root_temp=root;
    Sleeping_threads_add(thread_current()->priority, ticks, start, thread_current());

    //root_temp=root;
    //Sleeping_threads_print();
  }



  if (numOfProccess==6)
  {

  }
  //while (timer_elapsed (start) < ticks)
  // {
   // printf("waitL\n");
  //  thread_yield ();
   //}

}

/* Sleeps for approximately MS milliseconds.  Interrupts must be
   turned on. */
void
timer_msleep (int64_t ms)
{
  real_time_sleep (ms, 1000);
}

/* Sleeps for approximately US microseconds.  Interrupts must be
   turned on. */
void
timer_usleep (int64_t us)
{
  real_time_sleep (us, 1000 * 1000);
}

/* Sleeps for approximately NS nanoseconds.  Interrupts must be
   turned on. */
void
timer_nsleep (int64_t ns)
{
  real_time_sleep (ns, 1000 * 1000 * 1000);
}

/* Busy-waits for approximately MS milliseconds.  Interrupts need
   not be turned on.

   Busy waiting wastes CPU cycles, and busy waiting with
   interrupts off for the interval between timer ticks or longer
   will cause timer ticks to be lost.  Thus, use timer_msleep()
   instead if interrupts are enabled. */
void
timer_mdelay (int64_t ms)
{
  real_time_delay (ms, 1000);
}

/* Sleeps for approximately US microseconds.  Interrupts need not
   be turned on.

   Busy waiting wastes CPU cycles, and busy waiting with
   interrupts off for the interval between timer ticks or longer
   will cause timer ticks to be lost.  Thus, use timer_usleep()
   instead if interrupts are enabled. */
void
timer_udelay (int64_t us)
{
  real_time_delay (us, 1000 * 1000);
}

/* Sleeps execution for approximately NS nanoseconds.  Interrupts
   need not be turned on.

   Busy waiting wastes CPU cycles, and busy waiting with
   interrupts off for the interval between timer ticks or longer
   will cause timer ticks to be lost.  Thus, use timer_nsleep()
   instead if interrupts are enabled.*/
void
timer_ndelay (int64_t ns)
{
  real_time_delay (ns, 1000 * 1000 * 1000);
}

/* Prints timer statistics. */
void
timer_print_stats (void)
{
  printf ("Timer: %"PRId64" ticks\n", timer_ticks ());
}

/* Timer interrupt handler. */
static void
timer_interrupt (struct intr_frame *args UNUSED)
{
  ticks++;
  thread_tick ();
}

/* Returns true if LOOPS iterations waits for more than one timer
   tick, otherwise false. */
static bool
too_many_loops (unsigned loops)
{
  /* Wait for a timer tick. */
  int64_t start = ticks;
  while (ticks == start)
    barrier ();

  /* Run LOOPS loops. */
  start = ticks;
  busy_wait (loops);

  /* If the tick count changed, we iterated too long. */
  barrier ();
  return start != ticks;
}

/* Iterates through a simple loop LOOPS times, for implementing
   brief delays.

   Marked NO_INLINE because code alignment can significantly
   affect timings, so that if this function was inlined
   differently in different places the results would be difficult
   to predict. */
static void NO_INLINE
busy_wait (int64_t loops)
{
  while (loops-- > 0)
    barrier ();
}

/* Sleep for approximately NUM/DENOM seconds. */
static void
real_time_sleep (int64_t num, int32_t denom)
{
  /* Convert NUM/DENOM seconds into timer ticks, rounding down.

        (NUM / DENOM) s
     ---------------------- = NUM * TIMER_FREQ / DENOM ticks.
     1 s / TIMER_FREQ ticks
  */
  int64_t ticks = num * TIMER_FREQ / denom;

  ASSERT (intr_get_level () == INTR_ON);
  if (ticks > 0)
    {
      /* We're waiting for at least one full timer tick.  Use
         timer_sleep() because it will yield the CPU to other
         processes. */
      timer_sleep (ticks);
    }
  else
    {
      /* Otherwise, use a busy-wait loop for more accurate
         sub-tick timing. */
      real_time_delay (num, denom);
    }
}

/* Busy-wait for approximately NUM/DENOM seconds. */
static void
real_time_delay (int64_t num, int32_t denom)
{
  /* Scale the numerator and denominator down by 1000 to avoid
     the possibility of overflow. */
  ASSERT (denom % 1000 == 0);
  busy_wait (loops_per_tick * num / 1000 * TIMER_FREQ / (denom / 1000));
}