#include <xen/lib.h>
#include <xen/sched.h>
#include <xen/time.h>
#include <xen/sched-if.h>
#include <xen/softirq.h>
#include <xen/errno.h>
#include <xen/list.h>
#include <xen/timer.h>
#include <xen/randmd5.h>

int tot_vcpu=0;
MD5_CTX mdContext;

#define RAND_PCPU(_c)     ((struct random_pcpu *)per_cpu(schedule_data, _c).sched_priv)
#define RAND_VCPU(_vcpu)  ((struct random_vcpu *) (_vcpu)->sched_priv)
#define RUNQ(_cpu)        (&(RAND_PCPU(_cpu)->runq))

struct random_pcpu {
    struct list_head runq;
};

struct random_vcpu{
    struct list_head active_vcpu_elem; //all
    struct list_head runq_elem; //runnable
    struct vcpu *vcpu;
};

static int random_pcpu_init(int cpu);
static inline void __runq_insert(unsigned int cpu, struct random_vcpu *svc);

static int random_vcpu_init(struct vcpu *vc){
    struct random_vcpu *svc;

    svc = xmalloc(struct random_vcpu);
    if ( svc == NULL )
        return -1;
    memset(svc, 0, sizeof(*svc));
  
    INIT_LIST_HEAD(&svc->active_vcpu_elem);
    INIT_LIST_HEAD(&svc->runq_elem);

    svc->vcpu = vc;
    vc->sched_priv = svc;

  /* Allocate per-PCPU info */
    if ( unlikely(!RAND_PCPU(vc->processor)) )
    {
        if ( random_pcpu_init(vc->processor) != 0 )
            return -1;
    }

    //check CSCHED_VCPU_CHECK

    tot_vcpu++; 
    printk("\nadd VCPU %d\n", vc->vcpu_id);
    return 0;
}

static int random_pcpu_init(int cpu)
{
    struct random_pcpu *spc;
    /* Allocate per-PCPU info */
    spc = xmalloc(struct random_pcpu);
    if ( spc == NULL )
        return -1;
    memset(spc, 0, sizeof(*spc));
    INIT_LIST_HEAD(&spc->runq);
    per_cpu(schedule_data, cpu).sched_priv = spc;
    return 0;
}


static void random_vcpu_destroy(struct vcpu *v)
{
    printk("\n\nDESTROYING VCPU %d\n\n",v->vcpu_id);
    /*
    struct csched_vcpu * const svc = CSCHED_VCPU(vc);
    struct csched_dom * const sdom = svc->sdom;
    unsigned long flags;

    CSCHED_STAT_CRANK(vcpu_destroy);

    BUG_ON( sdom == NULL );
    BUG_ON( !list_empty(&svc->runq_elem) );

    spin_lock_irqsave(&csched_priv.lock, flags);

    if ( !list_empty(&svc->active_vcpu_elem) )
        __csched_vcpu_acct_stop_locked(svc);

    spin_unlock_irqrestore(&csched_priv.lock, flags);

    xfree(svc);*/
}


struct task_slice random_schedule(s_time_t now){
    const unsigned int cpu = smp_processor_id();
    struct list_head *runq = RUNQ(cpu);
    struct random_vcpu * const scurr = RAND_VCPU(current);
    struct random_vcpu *snext;
    struct task_slice ret;
    int next_vcpu=0;

    next_vcpu = (MD5Final (&mdContext))  % tot_vcpu;

    /*
     * Select next runnable local VCPU (ie top of local runq)
     */
    if ( vcpu_runnable(current) )
        __runq_insert(cpu, scurr);
  //  else
  //      BUG_ON( is_idle_vcpu(current) || list_empty(runq) );


    while (next_vcpu==0){
        next_vcpu--;
        runq=runq->next;
    }
    snext = list_entry(runq->next, struct random_vcpu, runq_elem);

    ret.time = MILLISECS(10);
    ret.task = snext->vcpu;

    return ret;
}


static void __random_init(void){
    unsigned char digest[16];
    int i;
    long unsigned int mask= 0xFF;
    long unsigned int string_now = NOW();
    MD5Init (&mdContext);
    printk("\n\nInit Random Number Generator\n");
    for (i=0;i<8;i++){
        digest[i]=(char) ((string_now & mask) >> 8*i);
        mask <<=8;
    }
    printk("Inizializzo il random con la parola %x", (unsigned int) digest);
    MD5Update (&mdContext, (unsigned char*)digest, sizeof(s_time_t));
    printk("\n\nUpdating Random Generator\n");

}

static void random_vcpu_wake( struct vcpu *vc){
    struct random_vcpu * const svc = RAND_VCPU(vc);
    const unsigned int cpu = vc->processor;
    cpumask_t mask;

    cpus_clear(mask);
    /* Put the VCPU on the runq and tickle CPUs */
    __runq_insert(cpu, svc);  //inserisce in coda la vcpu
    //    __runq_tickle(cpu, svc);  // raise softirq   

    printk("\n\nWAKE UP!!!!!!!!!!!!\n\n");
    if ( unlikely(!list_empty(&svc->runq_elem)) )
    {
        return;
    }

    if ( !is_idle_vcpu(vc) && likely(vcpu_runnable(vc)) ) 
    {
        cpu_set(cpu, mask);
        printk("\nI'm setting the mask for the current vcpu\n");
    }
    if ( !cpus_empty(mask) )
        cpumask_raise_softirq(mask, SCHEDULE_SOFTIRQ);    


    //cpu_raise_softirq(cpu,SCHEDULE_SOFTIRQ);
    __random_init();
    return;
}


static inline void __runq_insert(unsigned int cpu, struct random_vcpu *svc)
{
    const struct list_head * const runq = RUNQ(cpu);
    struct list_head *iter;

    list_for_each( iter, runq )
    {	
        list_add_tail(&svc->runq_elem, iter);
    }
    return; 
}

struct scheduler sched_rand_def = {
    .name           = "my Random Scheduler",
    .opt_name       = "random",
    .sched_id       = 17,
    .init_vcpu      = random_vcpu_init,
    .wake           = random_vcpu_wake,
    .destroy_vcpu   = random_vcpu_destroy,
    .do_schedule    = random_schedule,

};