#include "PointersLibs.h"

#define DAYS_IN_MONTH 30
#define MONTHS_IN_YEAR 12
#define ONE_HUNDRED 100
#define ONE_THOSEND 10000
#define BOOLEAN unsigned short
#define TRUE 1
#define FALSE 0
#define TEN 10
#define TWELVE 12
#define THIRTY 30
#define ZERO 0
#define ONE 1
#define TWO 2
#define THREE 3
#define FOUR 4
#define ABS(x) (x) * (((2 * (x)) + 1) % 2)
#define MAX(x, y) (x > y) ? x : y
#define MIN(x, y) (x < y) ? x : y
#define BACKSLASH_ZERO '\0'

//---------------------------------------------------------------------------------------
//                                        CharInString
//                                        ------------
//
// General      :CHecks if the char exist in string.
//
// Parameters   :  
//          text - string (char[])
//          c    - char (char)
//
// Return value : If the char exist in string (BOOLEAN).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
BOOLEAN CharInString(char text[], char c)
{
    BOOLEAN exist = FALSE;
    unsigned short counter = ZERO;
    while ((text[counter] != c) * text[counter++]);
    exist = (text[--counter] == c);

    return (exist);
}

char * LastCharOfString(char * start_string)
{
    while (*(start_string++));

    return (--start_string);
}

//---------------------------------------------------------------------------------------
//                                        StringLenght
//                                        ------------
//
// General      : Checks the lenght of string.
//
// Parameters   :  
//          text - string (char[])
//
// Return value : Lenght of string (unsigned short).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : None
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
unsigned short StringLenght(char *start_string)
{
    return (LastCharOfString(start_string) - start_string);
}

//---------------------------------------------------------------------------------------
//                                        StringCompare
//                                        ------------------------
//
// General      : Compare 2 strings.
//
// Parameters   :  
//          text1 - string (char[])
//          text2 - string (char[])
//
// Return value : If this 2 strings are equals (BOOLEAN).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
BOOLEAN StringCompare(char *start_stringA_index, char *start_stringB_index)
{
    while ((*start_stringA_index) && (*(start_stringA_index++) == *(start_stringB_index++)));

    return (*--start_stringA_index == *--start_stringB_index);
}

//---------------------------------------------------------------------------------------
//                                        IndexCharInString
//                                        -----------------
//
// General      : Find the index of char in the string.
//
// Parameters   :  
//          text - string (char[])
//          c    - char (char)
//
// Return value : The first index of the char in the string (unsigned short).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
unsigned short IndexCharInString(char text[], char c)
{
    unsigned short counter = ZERO;
    while (text[counter++] != c);

    return (--counter);
}

//---------------------------------------------------------------------------------------
//                                        CountCharInString
//                                        -----------------
//
// General      : Count how many the char is in the string.
//
// Parameters   :  
//          text - string (char[])
//          c    - char (char)
//
// Return value : Count of char in the string (unsigned short).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : None
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
unsigned short CountCharInString(char *start_string_index, char c)
{
    unsigned short count = ZERO;
    while (*start_string_index)
    {
        count += (*(start_string_index++) == c);
    }

    return (count);
}

//---------------------------------------------------------------------------------------
//                                        CutString
//                                        ---------
//
// General      : Cut the string.
//
// Parameters   :  
//          text  - string (char[])
//          start - from where (unsigned short)
//
// Return value : If the equation is ok (BOOLEAN).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : None
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
void CutString(char *start_textA_index, char *end_textA_index, char *start_textB_index)
{
    while (start_textA_index < end_textA_index)
    {
        *(start_textB_index++) = *(start_textA_index++);
    }
    *start_textB_index = BACKSLASH_ZERO;
    
}

//---------------------------------------------------------------------------------------
//                                        CopyString
//                                        ----------
//
// General      : Copy second string into first string.
//
// Parameters   :  
//          text  - first text (char[])
//          copy  - second text (char[])
//          start - from where to start (unsigned short)
//
// Return value : None.
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
void CopyString(char *start_string_index, char *start_copy_index)
{
    while (*start_copy_index)
    {
        *(start_string_index++) = *(start_copy_index++);
    }
    *(start_string_index) = BACKSLASH_ZERO;
}

//---------------------------------------------------------------------------------------
//                                        LinkingString
//                                        -------------
//
// General      : Copy second string into end of first string.
//
// Parameters   :  
//          textA  - first text (char[])
//          textB  - second text (char[])
//
// Return value : None.
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
void LinkingString(char *start_stringA_index, char *start_stringB_index)
{
    CopyString(LastCharOfString(start_stringA_index), start_stringB_index);
}

//---------------------------------------------------------------------------------------
//                                        ReverseString
//                                        -------------
//
// General      : Chnage to oppsite the string.
//
// Parameters   :  
//          textA  - first text (char[])
//
// Return value : None.
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
void ReverseString(char textA[])
{
    unsigned short textA_lenght = StringLenght(textA) - ONE,
                 counter,
                 loop_lenght = (textA_lenght + ONE) / TWO;
    char temp_char;
    for (counter = ZERO; counter < loop_lenght; counter++)
    {
        temp_char = textA[counter];
        textA[counter] = textA[textA_lenght - counter];
        textA[textA_lenght - counter] = temp_char;
    }
}

//---------------------------------------------------------------------------------------
//                                        StringBInStringA
//                                        ----------------
//
// General      : Check if string B exists in string A.
//
// Parameters   :  
//          textA  - first text (char[])
//          textB  - second text (char[])
//
// Return value : If string B exists in string A (BOOLEAN).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
/*BOOLEAN StringBInStringA(char textA[], char textB[])
{
    BOOLEAN exist = FALSE;
    unsigned short textA_lenght = StringLenght(textA);
    unsigned short textB_lenght = StringLenght(textB);
    char temp_textA[textA_lenght];
    unsigned short counter;
    unsigned short loop_length = textA_lenght - textB_lenght;
    for (counter = ZERO; (counter < loop_length) * !exist; counter++)
    {   
        CopyString(temp_textA, textA, ZERO);
        CutString(temp_textA, counter, textB_lenght);
        exist = StringCompare(temp_textA, textB);
    }
    
    return (exist);
}*/

//---------------------------------------------------------------------------------------
//                                        IndexStringBInStringA
//                                        ---------------------
//
// General      : Find the index of string B in string A.
//
// Parameters   :  
//          textA  - first text (char[])
//          textB  - second text (char[])
//
// Return value : Index of string B in string A (unsigned short).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
char * IndexStringBInStringA(char *start_string_a, char *start_string_b)
{
    char *ptr_string_a_temp = start_string_a;
    char temp = BACKSLASH_ZERO;
    BOOLEAN flag = FALSE;
    unsigned short textB_lenght = StringLenght(start_string_b);
    char *address = (ptr_string_a_temp + textB_lenght);
    while ((*(address - ONE)) * !flag)
    {
        SwapChars(&temp, address);
        flag = StringCompare(ptr_string_a_temp, start_string_b);
        SwapChars(&temp, address);
        address = ((++ptr_string_a_temp) + textB_lenght);
    }
    
    return (--ptr_string_a_temp);
}

//---------------------------------------------------------------------------------------
//                                        CountStringBInStringA
//                                        ---------------------
//
// General      : Counting how many times stringB in stringA.
//
// Parameters   :  
//          *start_string_a - Pointer of first string (char[])
//          *start_string_b - Pointer of second string (char[])
//
// Return value : Count second string in first string (unsigned int).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
unsigned int CountStringBInStringA(char *start_string_a, char *start_string_b)
{
    char *ptr_string_a_temp = start_string_a;
    char temp = BACKSLASH_ZERO;
    unsigned short count = ZERO;
    unsigned short textB_lenght = StringLenght(start_string_b);
    char *address = (ptr_string_a_temp + textB_lenght);
    while (*(address - ONE))
    {
        SwapChars(&temp, address);
        count += StringCompare(ptr_string_a_temp, start_string_b);
        SwapChars(&temp, address);
        address = ((++ptr_string_a_temp) + textB_lenght);
    }
    
    return (count);
}

//---------------------------------------------------------------------------------------
//                                        CountStringBInStringA
//                                        ---------------------
//
// General      : Remove first string B from string A.
//
// Parameters   :  
//          textA  - first text (char[])
//          textB  - second text (char[])
//
// Return value : None.
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
void RemoveStringBFromStringA(char *start_string_a, char *start_string_b)
{
    unsigned short textB_lenght = StringLenght(start_string_b);
    char *ptr_index_stringB_in_stringA = IndexStringBInStringA(start_string_a, start_string_b);
    CopyString(ptr_index_stringB_in_stringA, ptr_index_stringB_in_stringA + textB_lenght);
}

//---------------------------------------------------------------------------------------
//                                        CountStringBInStringA
//                                        ---------------------
//
// General      : Remove ALL string B from string A.
//
// Parameters   :  
//          textA  - first text (char[])
//          textB  - second text (char[])
//
// Return value : None.
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
void RemoveAllStringBFromStringA(char *start_stringA_index, char *start_stringB_index)
{
    unsigned short loop_lenght = CountStringBInStringA(start_stringA_index, start_stringB_index);
    unsigned short counter;
    for (counter = ZERO; counter < loop_lenght; counter++)
    {
        RemoveStringBFromStringA(start_stringA_index, start_stringB_index);
    }
}

//---------------------------------------------------------------------------------------
//                                        ValidParenthesesTemplate
//                                        ------------------------
//
// General      : checks if the string is a good equation.
//
// Parameters   :  
//          text - string (char[])
//
// Return value : If the equation is ok (BOOLEAN).
//
//---------------------------------------------------------------------------------------
// Programmer : Cohen Idan
// Student No : 211675038
// Date       : 04.10.2019
//---------------------------------------------------------------------------------------
BOOLEAN ValidParenthesesTemplate(char text[])
{
    unsigned short counter = ZERO;
    short count_parenthesis = ZERO;
    while (text[counter] * (count_parenthesis + ONE))
    {
        count_parenthesis += (text[counter] == '(');
        count_parenthesis -= (text[counter] == ')');
    }

    return (!count_parenthesis);
}

unsigned short CharToNumber(char *c)
{
    return (unsigned short)((*c) - '0'); 
}