#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, const char * argv[])
{
    char** arguments = malloc(1 * sizeof(char**));

    if (arguments)
    {
        //arguments[0] = malloc(strlen(argv[0]));
        //arguments[1] = malloc(1 * sizeof(*arguments[0]));

        FILE *fp;

        fp=fopen("test.txt", "r");

        if (fp==NULL)
        {
            fp=fopen("test.txt", "w");
            int pid=getpid();
            fprintf(fp,"%d", pid);
            fclose(fp);

            char test[1024];

            int counter = 0;

            for(int i =1; i < argc; i++)
            {
                for(int j = 0; j < (int)strlen(argv[i]); j++)
                {
                    if (argv[i][j] != '\0') test[counter] = argv[i][j];
                    counter++;
                }
            }
            test[counter + 1] = '\0';

            printf("Test : %s\n", test);


            int potega = 2;
            int dlugosc = 0;

            while (test[dlugosc] !='\0')
            {
                dlugosc++;
            }

            printf("Dlugosc : %d\n", dlugosc);

            while (1)
            {
                if(potega == dlugosc) break;
                if(potega < dlugosc)
                    {
                        potega *= 2;
                        if ( potega > dlugosc )
                        {
                            potega = potega / 2;
                            break;
                        }
                    }
            }

            char argument[potega+1];

            for(int i=0; i < potega; i++)
            {
                argument[i] = test[i];
            }

            argument[potega+1] = '\0';

            printf("Argument: %s\n", argument);

            //strncpy(argument, test, potega);

            //printf("Argument: %s\n", argument);

            //char * argument = NULL;

            //size_t dlugosc;*/
            /*
            for(int i=1; i<argc; i++)
            {
                char* tmp;
                dlugosc += strlen(argv[i]);
                tmp = realloc(argument, dlugosc);
                argument = tmp;
                strcat(argument, argv[i]);
            }
            */
            //printf("Argument: %s\n", argument);
            //printf("Dlugosc: %d\n", strlen(argument));

            /*char** tmp = realloc(arguments, 2 * sizeof(*arguments));

            size_t potega = 2;
            dlugosc = strlen(argument);



            if(tmp)
            {
                //arguments[1] = malloc(potega);
            }

            argc = 2;*/

            /*
            char* argument = malloc(dlugosc + 1);
            memcpy
            int counter = 0;

            if(argument)
            {
                argument[0] = '\0';

                for(int i=1; i < argc; i++)
                {
                    for(int j=0; j<(int)strlen(argv[i]); j++)
                    {
                        argument[counter] = argv[i][j];
                        counter++;
                    }
                }

                //printf("Argument: %s\n", argument);

                //int dlugosc = (int)strlen(argument);
                int potega = 2;

                while (1)
                {
                    if(potega == dlugosc) break;
                    if(potega < dlugosc)
                        {
                            potega *= 2;
                            if ( potega > dlugosc )
                            {
                                potega = potega / 2;
                                break;
                            }
                        }
                }




                //for(int i=0; i< potega;i++)
                //{
                    //arguments[1][i] = argument[i];
                //}
                //arguments[potega + 1] = '\0';

                char** tmp = realloc(arguments, 2 * sizeof(*arguments));

                if(tmp)
                {
                    arguments = tmp;

                    size_t n = strlen(argument) + 1;
                    arguments[1] = malloc(n);
                    memcpy(arguments[1], argument, n);

                    arguments[0] = argv[0];
                    argc = 2;
                    //char* buf = realloc(arguments[1], (potega + 1) * sizeof(char));
                    //char test[potega+1];

                    //for (int i=0; i < potega; i++)
                    //{
                    //  test[i] = argument[i];
                    //}
                    //test[potega] = '\0';
                    //printf("Test: %s\n", test);

                    //memcpy(arguments[1], argument, potega);
                    //arguments[1] = "";
                    //arguments[1] = realloc(arguments[1], (potega + 1) * sizeof(char));
                    //strncpy(arguments[1], argument, potega);
                    free(argument);
                }



                /*

                char* linkedArgument = malloc(potega* sizeof(char));

                if(linkedArgument)
                {
                    for(int i = 0; i < potega; i++)
                        {
                            linkedArgument[i] = argument[i];
                        }

                    free(argument);

                    char** tmp = realloc(arguments, 2 * sizeof(*arguments));

                    if(tmp)
                    {
                        arguments = tmp;
                        arguments[0] = argv[0];


                        //char* buf = realloc(arguments[1], potega * sizeof(char));
                        arguments[1] = linkedArgument;
                        //arguments[1] = linkedArgument;
                        //arguments[1] = malloc(potega * sizeof(char));
                        strncat(arguments[1], linkedArgument, potega);
                        //for(int i=0;i<potega;i++)
                        //{

                            //arguments[1][i] = linkedArgument[i];
                        //}
                        argc = 2;
                        //free(linkedArgument);
                        free(linkedArgument);
                    }
                }

                */

        }
        else
        {
            /*
            char** tmp = realloc(arguments, argc * sizeof(*arguments));
            if (tmp)
            {
                arguments = tmp;
                for(int i=0; i<argc; i++)
                {
                    arguments[i] = malloc (strlen(argv[i]));
                    arguments[i] = argv[i];
                }
            }*/
        }

        //int index = argc -1;
        //int lenght = strlen(arguments[1]);

        /*
        printf("Dlugosc: %d\n", lenght);

        if (lenght==1)
        {
            printf("%d ", getpid());
            for (int i = 1; i<argc; i++)
            {
                printf("%s ", arguments[i]);
            }
            printf("\n");
            exit(0);
        }

        char * pierwszy = malloc((lenght +1) * sizeof(char));
        char * drugi = malloc((lenght +1) * sizeof(char));

        for(int i=0; i< lenght; i++)
        {
            if(i < lenght /2)
            {
                pierwszy[i] = arguments[index][i];
            }
            else
            {
                drugi[i - lenght /2] = arguments[index][i];
            }
        }

        pierwszy[lenght] = '\0';
        drugi[lenght] = '\0';

        char * tablica[argc + 2];
        tablica[argc + 1] = NULL;

        for ( int i = 0; i<argc; i++ )
        {
            tablica[i] = arguments[i];
        }

        printf("Pierwszy: %s\n", pierwszy);
        printf("Drugi: %s\n", drugi);*/

        /*
        for(int i = 0; i< argc; i++)
        {
            free(arguments[i]);
        }*/
        free(arguments);
        //free(pierwszy);
        //free(drugi);

        int rootpid;
        fp=fopen("test.txt", "r");
        fscanf(fp, "%d", &rootpid);
        fclose(fp);

        if (rootpid==getpid())
        {
            remove("test.txt");
        }
    }
    return 0;
}