#ifndef __PROGTEST__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define LIST_BY_YEAR 0
#define LIST_BY_TYPE 1

#define TYPE_MAX 100
#define SETUP_MAX 100

typedef struct TEngine
{
    struct TEngine * m_Next;
    struct TEngine * m_Prev;
    int m_Year;
    char m_Type [ TYPE_MAX ];
    int m_Setup [ SETUP_MAX ];
} TENGINE;

typedef struct TArchive
{
    struct TArchive * m_Next;
    struct TArchive * m_Prev;
    TENGINE * m_Engines;
} TARCHIVE;

TENGINE * createEngine ( const char * type,
                         int year )
{
    TENGINE * res = (TENGINE *) malloc ( sizeof (*res ) );
    res -> m_Next = NULL;
    res -> m_Prev = NULL;
    res -> m_Year = year;
    strncpy ( res -> m_Type, type, sizeof ( res -> m_Type ) );
    for ( int i = 0; i < SETUP_MAX; i ++ )
        res -> m_Setup[i] = 0;
    return res;
}
#endif /* __PROGTEST__ */

TARCHIVE * AddEngine ( TARCHIVE * list,
                       int listBy,
                       TENGINE * engine )
{
    TARCHIVE *current = NULL;
    switch (listBy)
    {
        case (LIST_BY_TYPE) :
        {
            current = list;
            while(1)
            {
                if(!current)
                {
                    TARCHIVE *p = (TARCHIVE*)malloc(sizeof(*p));
                    p->m_Prev = NULL;
                    p->m_Next = NULL;
                    p->m_Next = list;
                    if(list) list->m_Prev = p;
                    list = p;
                    p->m_Engines = engine;
                    break;
                }
                if(strcmp(current-> m_Engines -> m_Type,engine ->m_Type) == 0)
                {
                    engine->m_Next = current ->m_Engines;
                    current->m_Engines->m_Prev = engine;
                    current->m_Engines=engine;
                    break;
                }
                current = current->m_Next;
            }
            current = list;
            while(current) {
                TENGINE *currentE = current->m_Engines;
                while (currentE->m_Next)
                {
                    if(currentE->m_Year > currentE->m_Next->m_Year)
                    {
                        int i = currentE->m_Year;
                        currentE->m_Year=currentE->m_Next->m_Year;
                        currentE->m_Next->m_Year=i;
                        currentE = current->m_Engines;
                        continue;
                    }
                    currentE = currentE ->m_Next;
                }
                current = current->m_Next;
            }
            current = list;
            while(current->m_Next)
            {
                if(strcmp(current->m_Engines->m_Type, current->m_Next->m_Engines->m_Type)>0)
                {
                    TENGINE *r=current->m_Engines;
                    current->m_Engines=current->m_Next->m_Engines;
                    current->m_Next->m_Engines = r;
                }
                current = current->m_Next;
            }
            return list;
        }
        case (LIST_BY_YEAR) :
        {
            current = list;
            while(1)
            {
                if(!current)
                {
                    TARCHIVE *p = (TARCHIVE*)malloc(sizeof(*p));
                    p->m_Prev = NULL;
                    p->m_Next = NULL;
                    p->m_Next = list;
                    if(list) list->m_Prev = p;
                    list = p;
                    p->m_Engines = engine;
                    break;
                }
                if(current->m_Engines -> m_Year==engine ->m_Year)
                {
                    engine->m_Next = current ->m_Engines;
                    current->m_Engines->m_Prev = engine;
                    current->m_Engines=engine;
                    break;
                }
                current = current->m_Next;
            }

            current = list;
            while(current) {
                TENGINE *currentE = current->m_Engines;
                while (currentE->m_Next)
                {
                    if(strcmp(currentE->m_Next->m_Type, currentE->m_Type) < 0)
                    {
                        char tmp[100];
                        strcpy(tmp, currentE->m_Type);
                        strcpy(currentE->m_Type, currentE->m_Next->m_Type);
                        strcpy(currentE->m_Next->m_Type, tmp);
                        currentE = current->m_Engines;
                        continue;
                    }
                    currentE = currentE ->m_Next;
                }
                current = current->m_Next;
            }

            current = list;
            while(current->m_Next)
            {
                if(current->m_Engines->m_Year > current->m_Next->m_Engines->m_Year)
                {
                    TENGINE *r=current->m_Engines;
                    current->m_Engines=current->m_Next->m_Engines;
                    current->m_Next->m_Engines = r;
                }
                current = current->m_Next;
            }
            return list;

        }

    }
}
void DelArchive ( TARCHIVE * list )
{
    while(list)
    {
        TARCHIVE *a=list->m_Next;
        while(list->m_Engines)
        {
            TENGINE *e = list->m_Engines->m_Next;
            free(list->m_Engines);
            list->m_Engines = e;
        }
        free(list);
        list = a;
    }

}
TARCHIVE * ReorderArchive ( TARCHIVE * list,
                            int listBy )
{
    TARCHIVE *current = list;
    TARCHIVE *r = NULL;
    TARCHIVE *na = NULL;
    while(current)
    {
        TENGINE *e = current->m_Engines;
        while(e)
        {
            TENGINE *n = e->m_Next;
            e->m_Next = NULL;
            e->m_Prev = NULL;
            r = AddEngine(r, listBy, e);
            e = n;
        }
        na = current->m_Next;
        free(current);
        current = na;
    }
    return r;
}
#ifndef __PROGTEST__
int main ( int argc,
           char * argv [] )
{
    return 0;
}
#endif /* __PROGTEST__ */