Lab3

#include <math.h>
#include <stdio.h>
#include <progbase.h>
#include <progbase/console.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>
#include <assert.h>
#include <time.h>

#define N 10

typedef struct PlanetInfo
{
    float orb_radius;
    float period_rotate;
} PlanetInfo;

typedef struct PlanetWithSputnik
{
    char Name[30];
    int sputnik_count;
    float mass;
}PlanetWithSputnik;

typedef struct Planet
{

    char Name[30];
    int sputnik_count;
    float mass;
    PlanetInfo add_info;
} Planet;

void PlanetToString(Planet *planet, char buf[200]);
void StringToPlanet(char buf[200], Planet *planet);
void PlanetArrayToString(Planet **planet, char buf[500]);
void StringToPlanetArray(char buf[500], Planet **planet);
int ArrSize(Planet **arr);
void RemoveAt(Planet **planet, int i);
void ReplaceAt(Planet **planet, int i, Planet *src);
void SetValue(Planet *p, char field[50], char value[50]);
void PrintPlanetsSputnikCountLessX(Planet **planets, int x,Planet ** planet2);
void TestPlanetToString();      //done
void TestStringToPlanet();      //done
void TestPlanetArrayToString(); // done
void TestStringToPlanetArray(); //done
void TestRemoveAt();            // done
void TestReplaceAt();           //done
void TestSetValue();            //done
void Testing();
void LoadFromFile(char *filename, Planet **planets);
void SaveToFile(char *filename, Planet **planets);
void Action();
void Menu();
void ActMenu(Planet **planets, int c, Planet **planets2);
void AddUserPlanet(Planet **planets);
void RemoveUserPlanet(Planet **planets);
void ReplaceUserPlanet(Planet **planets);
void PrintPlanets(Planet **planets);
void ReplaceField(Planet **planets);
void FindPlanets(Planet **planets,Planet** planets2);
void SavePlanetsToFile(Planet **planets);

int main(int argc, char *argv[])
{
    if (argv[1] == NULL)
        Action();
    else if (strcmp(argv[1], "-t") == 0)
        Testing();
    else

        return 0;
}

void Testing()
{
    void TestPlanetToString();
    void TestStringToPlanet();
    void TestPlanetArrayToString();
    void TestStringToPlanetArray();
    void TestRemoveAt();
    void TestReplaceAt();
    void TestSetValue();
}

void FindPlanets(Planet **planets, Planet** planets2)
{

    int x;
    Planet * planet1[10];
    printf("Input count of sattelites: ");
    scanf("%d", &x);
    getchar();
    PrintPlanetsSputnikCountLessX(planets, x, planet1);
}

void ReplaceField(Planet **planets)
{
    int i;
    printf("Input index of planet for field to replace: ");
    scanf("%d", &i);
    if (planets[i] == NULL || (i < 0) || (i >= N))
    {
        printf("Error input!");
        return;
    }

    char field[50];
    char newvalue[50];
    printf("Input field name: ");
    scanf("%s", field);
    printf("Input field value: ");
    scanf("%s", newvalue);

    SetValue(planets[i], field, newvalue);
}

void SavePlanetsToFile(Planet **planets)
{
    char filename[50];
    printf("Input file name: ");
    scanf("%s", filename);
    SaveToFile(filename, planets);
}
void ReplaceUserPlanet(Planet **planets)
{
    int i;
    printf("Input index of planet to replace: ");
    scanf("%d", &i);
    if (planets[i] == NULL || (i < 0) || (i >= N))
    {
        printf("Error input!");
        return;
    }

    printf("Input planet's name: ");
    scanf("%s", planets[i]->Name);
    printf("Input planet's sattelite count: ");
    scanf("%d", &planets[i]->sputnik_count);
    printf("Input planet's mass: ");
    scanf("%f", &planets[i]->mass);
    printf("Input planet's orb radius: ");
    scanf("%f", &planets[i]->add_info.orb_radius);
    printf("Input planet's period rotate: ");
    scanf("%f", &planets[i]->add_info.period_rotate);
}
void RemoveUserPlanet(Planet **planets)
{
    int i;
    printf("Input index of planet to delete: ");
    scanf("%d", &i);
    if (planets[i] == NULL || (i < 0) || (i >= N))
    {
        printf("Error input!\n");
        return;
    }

    RemoveAt(planets, i);
}

void AddUserPlanet(Planet **planets)
{
    int len = ArrSize(planets);
    if (len > N - 1)
    {
        printf("List if full!");
        return;
    }

    planets[len] = malloc(sizeof(Planet));

    printf("Input planet's name: ");
    scanf("%s", planets[len]->Name);
    getchar();
    int flag = true;
    printf("Input planet's sattelite count: ");
    do
    {
        flag = true;
        char a[20];
        fgets(a, 20, stdin);
        a[strlen(a) - 1] = '\0';
        int size = strlen(a);
        for (int i = 0; i < size; i++)
        {
            if (!isdigit(a[i]))
                flag = false;
        }
        if (flag && atoi(a) >= 0)
        {
            planets[len]->sputnik_count = atoi(a);
        }
        else
            flag = false;

    } while (!flag);
    printf("Input planet's mass: ");
    do
    {
        flag = true;
        char a[20];
        fgets(a, 20, stdin);
        a[strlen(a) - 1] = '\0';
        int size = strlen(a);
        for (int i = 0; i < size; i++)
        {
            if (!isdigit(a[i]) && a[i] != '.')
                flag = false;
        }
        if (flag && atof(a) >= 0)
        {
            planets[len]->mass = atof(a);
        }
        else
            flag = false;

    } while (!flag);
    printf("Input planet's orb radius: ");
    do
    {
        flag = true;
        char a[20];
        fgets(a, 20, stdin);
        a[strlen(a) - 1] = '\0';
        int size = strlen(a);
        for (int i = 0; i < size; i++)
        {
            if (!isdigit(a[i]) && a[i] != '.')
                flag = false;
        }
        if (flag && atof(a) >= 0)
        {
            planets[len]->add_info.orb_radius = atof(a);
        }
        else
            flag = false;

    } while (!flag);
    printf("Input planet's period rotate: ");
    do
    {
        flag = true;
        char a[20];
        fgets(a, 20, stdin);
        a[strlen(a) - 1] = '\0';
        int size = strlen(a);
        for (int i = 0; i < size; i++)
        {
            if (!isdigit(a[i]) && a[i] != '.')
                flag = false;
        }
        if (flag && atof(a) >= 0)
        {
            planets[len]->add_info.period_rotate = atof(a);
        }
        else
            flag = false;

    } while (!flag);
}
void Action()
{
    Planet *planets[N] = {NULL};
    Planet *planets2[N] = {NULL};
    int choise = 0;
    do
    {
        Console_clear();
        puts("1. Create empty list of planets\n2. Load planets from file\n3. Exit\nWaiting fot input...");
        scanf("%i", &choise);

        switch (choise)
        {
        case 2:
        {
            Console_clear();
            char filename[100] = "";
            puts("Input file name: ");
            scanf("%s", filename);
            getchar();
            LoadFromFile(filename, planets);
        }
        case 1:
        {
            do
            {
                Console_clear();
                PrintPlanets(planets);
                Menu();
                scanf("%i", &choise);
                getchar();
                ActMenu(planets, choise,planets2);
            } while (choise != 0);
            break;
        }
        case 3:
            Console_clear();
            puts("Bye bye...");
            sleepMillis(1500);
            choise = 3;
            break;
        default:
            break;
        }
    } while (choise != 3);
    Console_clear();
    for (int i = 0; i < ArrSize(planets); i++)
        free(planets[i]);
}

void ActMenu(Planet **planets, int c, Planet **planets2)
{
    switch (c)
    {
    case 1:
        Console_clear();
        AddUserPlanet(planets);
        Console_clear();
        break;
    case 2:
        Console_clear();
        RemoveUserPlanet(planets);
        Console_clear();
        break;
    case 3:
        Console_clear();
        ReplaceUserPlanet(planets);
        Console_clear();
        break;
    case 4:
        Console_clear();
        ReplaceField(planets);
        Console_clear();
        break;
    case 5:
        // Planet **planets2;
        Console_clear();

        FindPlanets(planets, planets2);
        Console_clear();
        break;
    case 6:
        Console_clear();
        SavePlanetsToFile(planets);
        Console_clear();


        break;
        case 7:
        PrintPlanets(planets2);
        break;
    default:
        break;
    }
}
void PrintPlanets(Planet **planets)
{
    if (ArrSize(planets) != 0)
    {
        puts("Your list\n-------------------------------------------");
        for (int i = 0; i < ArrSize(planets); i++)
            printf("(Planet %i)\n Name: %s Sattelites: %i Mass: %.2f Radius: %.2f Period: %.2f\n", i, planets[i]->Name, planets[i]->sputnik_count, planets[i]->mass,
                   planets[i]->add_info.orb_radius, planets[i]->add_info.period_rotate);
        puts("-------------------------------------------");
    }
    else
        puts("This list is empty");
}
void Menu()
{
    printf("1. Add new planet\n");
    printf("2. Remove planet at index\n");
    printf("3. Edit planet at index\n");
    printf("4. Edit planet field at index\n");
    printf("5.  planet sattelites count less than X\n");
    printf("6. Save To File\n");
    printf("0. Exit\n");
    printf("7. Print planet sattelites count less than X\n");
}
void SaveToFile(char *filename, Planet **planets)
{
    FILE *f = fopen(filename, "w");

    char buf[200];
    for (int i = 0; i < ArrSize(planets); i++)
    {
        PlanetToString(planets[i], buf);
        fputs(buf, f);
    }

    fclose(f);
}

void LoadFromFile(char *filename, Planet **planets)
{

    FILE *f = fopen(filename, "r");

    if (f == 0)
        return;
    int count_planets_in_file = 0;
    char buf[200];
    while (fgets(buf, 200, f))
        count_planets_in_file++;
    rewind(f);

    for (int i = 0; i < count_planets_in_file; i++)
        planets[i] = malloc(sizeof(Planet));

    int i = 0;
    while (fgets(buf, 200, f))
    {
        StringToPlanet(buf, planets[i]);
        i++;
    }

    fclose(f);
}

void TestSetValue()
{
    Planet *planets[N] = {NULL};

    char buf[500] = "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\n";
    StringToPlanetArray(buf, planets);

    SetValue(planets[0], "Name", "Venera-12");
    SetValue(planets[1], "sputnik_count", "5");
    assert(strcmp(planets[0]->Name, "Venera-12") == 0);
    assert(planets[1]->sputnik_count == 5);

    free(planets[0]);
    free(planets[1]);
}

void TestReplaceAt()
{
    Planet *planets[N] = {NULL};
    planets[0] = malloc(sizeof(Planet));
    planets[1] = malloc(sizeof(Planet));
    char buf[500] = "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\n";
    StringToPlanetArray(buf, planets);

    Planet p = {"Neptun", 9, 8.5, {24.6, 23.0}};

    ReplaceAt(planets, 1, &p);

    assert(strcmp(planets[1]->Name, "Neptun") == 0);
    assert(planets[1]->sputnik_count == 9);
    free(planets[0]);
    free(planets[1]);
}

void TestRemoveAt()
{
    Planet *planets[N] = {NULL};
    planets[0] = malloc(sizeof(Planet));
    planets[1] = malloc(sizeof(Planet));
    planets[2] = malloc(sizeof(Planet));
    char buf[500] = "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\nNeptun;9;8.50;24.60;23.00\n";
    StringToPlanetArray(buf, planets);
    RemoveAt(planets, 1);
    assert(strcmp(planets[1]->Name, "Neptun") == 0);

    free(planets[0]);
    free(planets[1]);
}
void TestPlanetArrayToString()
{
    Planet *planets[N] = {NULL};
    planets[0] = malloc(sizeof(Planet));
    planets[1] = malloc(sizeof(Planet));
    planets[2] = malloc(sizeof(Planet));
    strcpy(planets[0]->Name, "Venera");
    strcpy(planets[1]->Name, "Mars");
    strcpy(planets[2]->Name, "Neptun");
    planets[0]->mass = 4.5;
    planets[0]->sputnik_count = 8;
    planets[0]->add_info.orb_radius = 14.6;
    planets[0]->add_info.period_rotate = 13;

    planets[1]->mass = 6.5;
    planets[1]->sputnik_count = 8;
    planets[1]->add_info.orb_radius = 14.6;
    planets[1]->add_info.period_rotate = 13;

    planets[2]->mass = 8.5;
    planets[2]->sputnik_count = 9;
    planets[2]->add_info.orb_radius = 24.6;
    planets[2]->add_info.period_rotate = 23;

    //s;fsdsdsd
    char buf[500] = "";
    PlanetArrayToString(planets, buf);

    assert(strcmp(buf, "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\nNeptun;9;8.50;24.60;23.00\n") == 0);

    free(planets[0]);
    free(planets[1]);
    free(planets[2]);
}

void TestStringToPlanetArray()
{
    Planet *planets[N] = {NULL};

    char buf[500] = "";

    strcpy(buf, "Venera;8;4.50;14.60;13.00\nMars;8;6.50;14.60;13.00\nNeptun;9;8.50;24.60;23.00\n");
    StringToPlanetArray(buf, planets);

    assert(planets[0]->sputnik_count == 8);
    assert(strcmp(planets[1]->Name, "Mars") == 0);
    assert(planets[2]->add_info.period_rotate == 23.0);

    free(planets[0]);
    free(planets[1]);
    free(planets[2]);
}

void TestStringToPlanet()
{
    char buf[100];
    Planet *p = malloc(sizeof(Planet));
    strcpy(buf, "Venera;10;5.60;3.20;16.00\n");
    StringToPlanet(buf, p);
    //-----------------
    strcpy(buf, "Venera;10;5.60;3.20;16.00\n");
    StringToPlanet(buf, p);
    assert(p->sputnik_count == 10);
    //------------

    free(p);
}

void TestPlanetToString()
{
    Planet *p = malloc(sizeof(Planet));
    p->mass = 5.6;
    strcpy(p->Name, "Venera");
    p->sputnik_count = 10;
    p->add_info.orb_radius = 3.2;
    p->add_info.period_rotate = 16;

    char str[100];
    PlanetToString(p, str);
    assert(strcmp("Venera;10;5.60;3.20;16.00\n", str) == 0);
    free(p);
    //------------------------
    p = malloc(sizeof(Planet));
    p->mass = 125.6;
    strcpy(p->Name, "Mars");
    p->sputnik_count = 10;
    p->add_info.orb_radius = 3.2;
    p->add_info.period_rotate = 16;
    PlanetToString(p, str);
    assert(strcmp("Venera;10;5.125.60;3.20;16.00\n", str) == 0);
    free(p);
    //------------------------

    p = malloc(sizeof(Planet));
    p->mass = 125.6;
    strcpy(p->Name, "Neptun");
    p->sputnik_count = 5;
    p->add_info.orb_radius = 3.8;
    p->add_info.period_rotate = 26;
    PlanetToString(p, str);
    assert(strcmp("Venera;10;5.125.60;3.20;16.00\n", str) == 0);
    free(p);

    p = malloc(sizeof(Planet));
    p->mass = 125.6;
    strcpy(p->Name, "Pluton");
    p->sputnik_count = 8;
    p->add_info.orb_radius = 5.9;
    p->add_info.period_rotate = 45;
    PlanetToString(p, str);
    assert(strcmp("Venera;10;5.125.60;3.20;16.00\n", str) == 0); //?
    free(p);
}

void SetValue(Planet *p, char field[50], char value[50])
{
    if (strcmp(field, "Name") == 0)
        strcpy(p->Name, value);
    else if (strcmp(field, "sputnik_count") == 0)
        sscanf(value, "%d", &p->sputnik_count);
    else if (strcmp(field, "mass") == 0)
        sscanf(value, "%f", &p->mass);
    else if (strcmp(field, "orb_radius") == 0)
        sscanf(value, "%f", &p->add_info.orb_radius);
    else if (strcmp(field, "period_rotate") == 0)
        sscanf(value, "%f", &p->add_info.period_rotate);
}

void PlanetArrayToString(Planet **planet, char buf[500])
{
    int len = 0;
    while (planet[len] != NULL)
        ++len;

    for (int i = 0; i < len; i++)
    {
        char str[100] = "";

        PlanetToString(planet[i], str);
        strcat(buf, str);
    }
}

void PrintPlanetsSputnikCountLessX(Planet **planets, int x, Planet ** planet2)
{
    int k = 0;

    for (int i = 0; i < ArrSize(planets); i++)
        if (planets[i]->sputnik_count < x)
            {
                // printf("Name: %s Sattelites: %i Mass: %.2f Radius: %.2f Period: %.2f\n", planets[i]->Name, planets[i]->sputnik_count, planets[i]->mass,
                //    planets[i]->add_info.orb_radius, planets[i]->add_info.period_rotate);
                planet2[k] = planets[i];
            }
    // puts("Press any key...");
    // getchar();
}

void ReplaceAt(Planet **planet, int i, Planet *src)
{
    if ((planet[i] == NULL) || (i < 0) || (i > ArrSize(planet)))
        return;

    *planet[i] = *src;
}

void StringToPlanetArray(char buf[500], Planet **planet)
{

    int pcount = 0;
    for (int i = 0; i < strlen(buf); i++)
        if (buf[i] == '\n')
            pcount++;
    char *oneplanet = strtok(buf, "\n");
    for (int i = 0; i < pcount; i++)
    {
        Planet *p = malloc(sizeof(Planet));
        StringToPlanet(oneplanet, p);
        planet[i] = p;
        oneplanet = strtok(NULL, "\n");
    }
}

void PlanetToString(Planet *planet, char buf[200])
{

    sprintf(buf, "%s;%i;%.2f;%.2f;%.2f\n", planet->Name, planet->sputnik_count, planet->mass,
            planet->add_info.orb_radius, planet->add_info.period_rotate);
}

void StringToPlanet(char buf[200], Planet *planet)
{

    sscanf(buf, "%[^;];%i;%f;%f;%f", planet->Name, &planet->sputnik_count, &planet->mass,
           &planet->add_info.orb_radius, &planet->add_info.period_rotate);
}

int ArrSize(Planet **planets)
{
    int len = 0;

    while (planets[len] != NULL)
        ++len;

    return len;
}

void RemoveAt(Planet **planet, int i)
{

    if ((planet[i] == NULL) || (i < 0) || (i > ArrSize(planet)))
        return;

    Planet *temp = planet[i];
    for (int j = i + 1; j <= ArrSize(planet); j++)
        planet[j - 1] = planet[j];

    free(temp);

    }