#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

short int addToFile(char *directory, char *text);
char* expandRealloc(char *ptrS, size_t n);
char* getWord(FILE *ptr);
short int checkDenied(const char *str);
char* reverseString(char *baseString);
int sortCompare(const void *a, const void *b);

char signHold[2];

int main(int argc, char* argv[])
{
    FILE *infile = NULL;
    char *string = NULL;
    int flag = 1;
    int flagNext = 0;
    if(argc != 3)
    {
        printf("Error: Improper number of arguments");
        return EXIT_FAILURE;
    }

    remove(argv[2]);
    if((addToFile(argv[2], "")) == 1)
        return 1;
    if((infile = fopen(argv[1], "r")) == NULL)
    {
    perror("Error");
    return 1;
    }

    while(feof(infile) == 0)
    {
        string = getWord(infile);

        if(checkDenied(string))
        {
            if(flag == 1)
            {
                addToFile(argv[2], string);
            }
            else
            {
                addToFile(argv[2], string);
                addToFile(argv[2], string);
                flag = 1;
            }
        }
        else
        {
            if (flag == 1)
            {
                addToFile(argv[2], string);
            }
            else
            {
                addToFile(argv[2], string);
                addToFile(argv[2], string);
            }
        flag = 0;
        }
        /*if(flag == 1)
        {
        if((addToFile(argv[2], string)) == 1)
            {
                fclose(infile);
                free(string);
                return 1;
            }
        /*qsort(string,strlen(string),sizeof(char),&sortCompare);flag = 0;
        }
        if(!checkDenied(string))
        {

            /*string = reverseString(string);
        }

            if((addToFile(argv[2], string)) == 1)
            {
                fclose(infile);
                free(string);
                return 1;
            }*/

        if(signHold[0] != EOF)
            if((addToFile(argv[2], signHold)) == 1)
            {

                fclose(infile);
                free(string);
                return 1;

            }

        free(string);
    }

    fclose(infile);
    return EXIT_SUCCESS;
}

short int addToFile(char *directory, char* text)
{
    FILE *ptr;
    if((ptr = fopen(directory, "a+")) == NULL)
        return 1;
    fprintf(ptr, "%s", text);
    fclose(ptr);
    return EXIT_SUCCESS;
}

char* expandRealloc(char *ptrS, size_t n)
{
    void *tmp = NULL;

    if((tmp = realloc(ptrS,n)) == NULL)
    {
        perror("Error");
        exit(EXIT_FAILURE);
    }
    else
    {
        ptrS = tmp;
        return ptrS;
    }
}

char* getWord(FILE* ptr)
{
    char* tempString = NULL;
    size_t memSize = 0;
    int c;

    tempString = expandRealloc(NULL, sizeof(char));
    while((c = fgetc(ptr)))
    {

        if(isalpha(c) != 0)
        {
            tempString = expandRealloc(tempString, (memSize+1)*sizeof(char));
            tempString[memSize] = c;
            ++memSize;
        }
        else
        {

            signHold[0] = c;
            signHold[1] = '\0';
            break;
        }
    }
        tempString = expandRealloc(tempString, (memSize+1)*sizeof(char));
    tempString[memSize] = '\0';
    return tempString;
}

short int checkDenied(const char *str)
{
    int i;
    i = strspn("h", str);
    i += strspn("H", str);

    if(i >= 1)
    {
        i = strspn("e", str);
        i += strspn("E", str);

        if(i >= 1)
        {
            i = strspn("t", str);
            i += strspn("T", str);

            if(i == 0)
            {
                return 0;
            }
        }
    }
    return 1;
}

char* reverseString(char *baseString)
{
    char* revString;
    int stringLen;
    int counter = 0;

    stringLen = strlen(baseString);
    revString = expandRealloc(NULL, (stringLen+1)*sizeof(char));

    for(counter = 0; counter < stringLen; counter++)
    {
        revString[stringLen - counter - 1] = baseString[counter];
    }

    free(baseString);
    revString[stringLen] = '\0';

    return revString;
}

int sortCompare(const void *a, const void *b)
{
    char c1 = *((const char*)(a));
    char c2 = *((const char*)(b));
    const char dif = ('a' - 'A');

    if ((c1 <= 'Z') && (c1 >= 'A'))
    {
        c1 += dif;
    }

    if ((c2 <= 'Z') && (c2 >= 'A'))
    {
        c2 += dif;
    }

    return (c1 > c2);
}