#include <stdlib.h>

#include <stdio.h>

#include <assert.h>

#include "msg.h"

static enum

{

    FREE,

    WAITING

} state = FREE;

struct Job

{

    int jobid;

    char command[CMD_LEN];

    enum Jobstate state;

    struct Job *next;

};

/* Globals */

static struct Job *firstjob = 0;

static jobids = 0;

static void send_list_line(int s, const char * str)

{

    struct msg m;

    int res;

    m.type = LIST_LINE;

    strcpy(m.u.line, str);

    res = write(s, &m, sizeof(m));

    if(res == -1)

        perror("write");

}

void s_list(int s)

{

    int i;

    struct Job *p;

    char buffer[LINE_LEN];

    sprintf(buffer, "ID\tState\tCommand\n");

    send_list_line(s,buffer);

    p = firstjob;

    while(p != 0)

    {

        sprintf(buffer, "%i\t%i\t%s\n",

                p->jobid,

                p->state,

                p->command);

        send_list_line(s,buffer);

        p = p->next;

    }

}

static struct Job * newjobptr()

{

    struct Job *p;

    if (firstjob == 0)

    {

        firstjob = (struct Job *) malloc(sizeof(*firstjob));

        firstjob->next = 0;

        return firstjob;

    }

    p = firstjob;

    while(p->next != 0)

        p = p->next;

    p->next = (struct Job *) malloc(sizeof(*p));

    p->next->next = 0;

    return p->next;

}

/* Returns job id */

int s_newjob(struct msg *m)

{

    struct Job *p;

    p = newjobptr();

    p->jobid = jobids++;

    p->state = QUEUED;

    strcpy(p->command, m->u.command);

    return p->jobid;

}

void s_removejob(int jobid)

{

    struct Job *p;

    struct Job *newnext;

    if (firstjob->jobid == jobid)

    {

        struct Job *newfirst;

        /* First job is to be removed */

        newfirst = firstjob->next;

        free(firstjob);

        firstjob = newfirst;

        return;

    }

    p = firstjob;

    /* Not first job */

    while (p->next != 0)

    {

        if (p->next->jobid == jobid)

            break;

        p = p->next;

    }

    assert(p->next != 0);

    newnext = p->next->next;

    free(p->next);

    p->next = newnext;

}

/* -1 if no one should be run. */

int next_run_job()

{

    if (state == WAITING)

        return -1;

    if (firstjob != 0)

        return firstjob->jobid;

    return -1;

}

void job_finished()

{

    struct Job *newfirst;

    assert(state == WAITING);

    assert(firstjob != 0);

    newfirst = firstjob->next;

    free(firstjob);

    firstjob = newfirst;

    state = FREE;

}