#define _CRT_SECURE_NO_WARNINGS

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

void premenNaMalePismena(char *retazec);
char *charVStringu(const char *s, int c);
char *nacitajSekvenciuZoSuboru();
void vypisSekvencieOdPozicie(char *sekvencia, unsigned int od, unsigned int potial);
signed int hladaj(char *prvyRetazec, char *druhyRetazec, int pozicia);
int zratajPismena(char * sekvencia, char pismeno);
void histogramSekvencie(char *sekvencia);
void najdlhsiPodretazecVSekvencii(char *retazec);
char *vlozSekvenciuOdPozicie(unsigned int pozicia, unsigned int dlzka, char *novaSekvencia, char *sekvencia);
void najdiPodretazecVSekvencii(unsigned int len, char *sekvencia, char *pattern);
char *podretazec(char *vstup, int start, int len);
void najdiPozicie(char *sekvencia, char pismeno, int velkost);

int main()
{
	char *dnaSekvencia = NULL;
	char novaSekvencia[1000];
	char vyber = '\0';
	unsigned int od = 0, potial = 0;

	while (vyber != 'k')
	{
		scanf(" %c", &vyber);
		if (vyber == 'n')
		{
			if (dnaSekvencia != NULL)
			{
				free(dnaSekvencia);
				dnaSekvencia = NULL;
			}
			dnaSekvencia = nacitajSekvenciuZoSuboru();
		}
		else if (vyber == 'p')
		{
			scanf("%d %s", &potial, novaSekvencia);
			najdiPodretazecVSekvencii(potial, dnaSekvencia, novaSekvencia);
		}
		else if (vyber == 'h')
		{
			histogramSekvencie(dnaSekvencia);
		}
		else if (vyber == 'o')
		{
			najdlhsiPodretazecVSekvencii(dnaSekvencia);
		}
		else if (vyber == 'v')
		{
			scanf("%d %d", &od, &potial);
			vypisSekvencieOdPozicie(dnaSekvencia, od, potial);
		}
		
		else if (vyber == 'l')
		{
			scanf("%d %d %s", &od, &potial, novaSekvencia);
			dnaSekvencia = vlozSekvenciuOdPozicie(od, potial, novaSekvencia, dnaSekvencia);
		}
	}

	return 0;
}

//funkcia na orezanie retazca
char *podretazec(char *vstup, int start, int len)
{
	char *ret = (char *)malloc((len + 1) * sizeof (char));
	memcpy(ret, vstup + start, len);
	ret[len] = '\0';
	return ret;
}

//funkcia na premenu retazca na male pismena, 
void premenNaMalePismena(char *string)
{
	char* sekvencia = string;
	for (; *sekvencia; ++sekvencia) *sekvencia = tolower(*sekvencia);
}

//funkcia na hladanie podretazca v retazci od pozicie
signed int hladaj(char *prvyRetazec, char *druhyRetazec, int pozicia)
{
	int i = pozicia, j = 0, vyskyt;
	char act = prvyRetazec[i];
	premenNaMalePismena(druhyRetazec);
	premenNaMalePismena(prvyRetazec);

	for (;;)
	{
		act = prvyRetazec[i];
		if ('\0' == act)
		{
			break;
		}
		while (prvyRetazec[i] != druhyRetazec[0] && prvyRetazec[i] != '\0')
		{
			i++;
		}
		if (prvyRetazec[i] == '\0')
		{
			return(-1);
		}

		vyskyt = i;

		while (prvyRetazec[i] == druhyRetazec[j] && prvyRetazec[i] != '\0' && druhyRetazec[j] != '\0')
		{
			i++;
			j++;
		}

		if (druhyRetazec[j] == '\0')
		{
			return vyskyt;
		}
		if (prvyRetazec[i] == '\0')
		{
			return -1;
		}

		i = vyskyt + 1;
		j = 0;
	}
	return -1;
}

//funkcia na zistenie ci je v stringu dane pismeno
char *charVStringu(const char *s, int c)
{
	const char ch = c;

	for (; *s != ch; s++)
	if (*s == '\0')
		return 0;
	return (char *)s;
}

//funkcia na nacitanie sekvencie zo suboru
char *nacitajSekvenciuZoSuboru()
{

	int ukazovatel = 0;
	int velkost = 0;
	char *sekvencia = NULL;
	//otvorime subor
	FILE *file = fopen("DNAsekvencia.txt", "r");

	//skontrolujeme, ci je subor otvoreny
	if (file == NULL)
	{
		printf("Subor sa nepodarilo otvorit\n");
		return NULL;
	}

	//spocitame pocet pismen v subore
	while (fgetc(file) != EOF) velkost++;

	//pretoze je ukazovatel na konci suboru, vratime ho na zaciatku
	rewind(file);

	//alokujeme string velkosti suboru + 1 na terminator znak
	sekvencia = (char *)malloc((velkost + 1) * sizeof(char));
	fgets(sekvencia, velkost + 1, file);

	//skontrolujeme, ci sa subor uzavrel
	if (fclose(file) == EOF)
	{
		printf("Subor sa nepodaril zavriet\n");
	}

	//skontrolujeme, ci je sekvencia platna
	for (ukazovatel; ukazovatel < velkost; ukazovatel++)
	{
		if (charVStringu("ACGTacgt", (int)sekvencia[ukazovatel]) != NULL)
		{
			continue;
		}
		else
		{
			printf("Sekvencia nesplna podmienky\n");
			return NULL;
		}
	}

	printf("Sekvenciu sa podarilo nacitat\n");
	return sekvencia;

}

//funkcia na vypis sekvencie
void vypisSekvencieOdPozicie(char *sekvencia, unsigned int od, unsigned int potial)
{
	if (sekvencia == NULL)
	{
		printf("Sekvencia nie je nacitana\n");
		return;
	}

	//osetrime nerealne scenare
	if (od < 1 || potial < 1 || od > potial || ((od + potial + -1) > strlen(sekvencia)))
	{
		printf("Zadanu podsekvenciu nie je mozne vypisat\n");
		return;
	}
	for (od; od <= potial; od++)
	{
		printf("%c", sekvencia[od - 1]);
	}
	printf("\n");

}

//funkcia ktora nam vrati pocet pismen v sekvencii
int zratajPismena(char * sekvencia, char pismeno)
{
	int var = 0;
	int i = 0;
	for (i; i < strlen(sekvencia); i++)
	{
		if (sekvencia[i] == toupper(pismeno) || sekvencia[i] == pismeno)
		{
			var++;
		}
	}
	return var;
}

//funkcia na vypis histogramu
void histogramSekvencie(char *sekvencia)
{
	unsigned int t = 0, a = 0, g = 0, c = 0, i = 0;

	if (sekvencia == NULL)
	{
		printf("Sekvencia nie je nacitana\n");
		return;
	}

	printf("A: %d\nC: %d\nG: %d\nT: %d\n",
		zratajPismena(sekvencia, 'a'),
		zratajPismena(sekvencia, 'c'),
		zratajPismena(sekvencia, 'g'),
		zratajPismena(sekvencia, 't'));
}

//funkcia na najdenie podretazcov v sekvencii
void najdiPodretazecVSekvencii(unsigned int dlzka, char *sekvencia, char *pattern)
{
	char *skopirovanyPattern;
	char *skopirovanaSekvencia;

	if (sekvencia == NULL)
	{
		printf("Sekvencia nie je nacitana\n");
		return;
	}
	skopirovanaSekvencia = (char *)malloc((strlen(sekvencia) + 1)* sizeof(char));

	strcpy(skopirovanaSekvencia, sekvencia);
	premenNaMalePismena(pattern);
	premenNaMalePismena(skopirovanaSekvencia);


	unsigned int i = 0, j, count = 0;

	//osetrime ze ak sme zadali dlhsi string, nez sme si zadali, tak nech oreze
	if (strlen(pattern) >= dlzka)
	{
		skopirovanyPattern = (char *)malloc(strlen(pattern) * sizeof(char));
		skopirovanyPattern = podretazec(pattern, 0, dlzka);
	}
	else
	{
		skopirovanyPattern = (char *)malloc(strlen(pattern) * sizeof(char));
		strcpy(skopirovanyPattern, pattern);
	}

	//najdeme prvy vyskyt podretazca
	i = hladaj(skopirovanaSekvencia, skopirovanyPattern, 0);

	for (i; i < strlen(skopirovanaSekvencia);)
	{
		count = 0;
		printf("%d ", i + 1);
		if (i == -1)
		{
			break;
		}
		//ak je to nahodou na zaciatku, tak nech nam to vyplni ciarkami
		if (i + 1 == 1)
		{
			//vypln ciarkami
			for (j = 0; j < 3; j++)
			{
				printf("-");
			}
			//povodny podretazec
			for (j = i; j < i + strlen(skopirovanyPattern); j++)
			{
				printf("%c", toupper(skopirovanaSekvencia[j]));
			}
			//ak je dalsi retazec za povodnym podretazcom v retazci, tak nam to vypise
			if ((i + strlen(skopirovanyPattern) + 3) < strlen(skopirovanaSekvencia))
			{
				for (j; j < i + strlen(skopirovanyPattern) + 3; j++)
				{
					printf("%c", toupper(skopirovanaSekvencia[j]));
				}
			}
			else
			{
				for (j; j < i + strlen(skopirovanyPattern) + 3; j++)
				{
					printf("-");
				}
			}
			printf("\n");
			//najdeme miesto dalsej sekvencie a nastavi index na miesto, kde sa to zacina
			i = hladaj(skopirovanaSekvencia, skopirovanyPattern, i + 1);
			continue;
		}
		//ak sa blizime ku koncu, tak dokym mame chary, dovtedy vypisujeme
		else
		{
			for (j = i; j < i + strlen(skopirovanyPattern); j++)
			{
				printf("%c", toupper(skopirovanaSekvencia[j]));
				count++;
			}
			for (j = i - 3; j < i; j++)
			{
				printf("%c", toupper(skopirovanaSekvencia[j]));
				count++;
			}
			if ((i + strlen(skopirovanyPattern) + 3) < strlen(skopirovanaSekvencia))
			{
				for (j; j < i + strlen(skopirovanyPattern) + 3; j++)
				{
					printf("%c", toupper(skopirovanaSekvencia[j]));
					count++;
				}
			}
			else
			{
				//kym su chary
				while (*(skopirovanaSekvencia + j) != '\0')
				{
					count++;
					printf("%c", toupper(*(skopirovanaSekvencia + j)));
					j++;
				}
				 //ak uz chary nie su, doplnime ciarkami na plnu dlzku, podla toho, ze count je jak velke
				for (j = count; j < 8; j++)
				{
					printf("-");
				}
			}

			printf("\n");
			i = hladaj(skopirovanaSekvencia, skopirovanyPattern, i + 1);
			continue;
		}
	}
}

char *vlozSekvenciuOdPozicie(unsigned int pozicia, unsigned int dlzka, char *novaSekvencia, char *sekvencia)
{
	char *novaDNASekvencia = NULL;
	char *skopirovanyPattern = NULL;
	int velkost = 0;

	if (sekvencia == NULL)
	{
		printf("Sekvencia nie je nacitana\n");
		return sekvencia;
	}
	//osetrime scenare
	if (pozicia < 1 || pozicia > strlen(sekvencia) + 1)
	{
		printf("Do sekvencie nie je mozne podsekvenciu vlozit\n");
		return sekvencia;
	}
	velkost = (dlzka + strlen(sekvencia) + 2);

	//naalokujeme novy retazec
	novaDNASekvencia = (char *)malloc(velkost * sizeof(char));
	memset(novaDNASekvencia, '\0', velkost);
	skopirovanyPattern = podretazec(novaSekvencia, 0, dlzka);
	//prekopirujeme zaciatok
	strncpy(novaDNASekvencia, sekvencia, pozicia - 1);
	//sekvenciu na vlozenie
	strcpy(novaDNASekvencia + strlen(novaDNASekvencia), skopirovanyPattern);
	//ostatok sekvencie
	strcpy(novaDNASekvencia + strlen(novaDNASekvencia), sekvencia + pozicia - 1);
	printf("Podsekvencia vlozena\n");
	return novaDNASekvencia;

}

//pomocna funkcia na najdenie pozicii kde sa podretazec v retazci nachadza
void najdiPozicie(char *sekvencia, char pismeno, int velkost)
{
	int i = 0;
	char *kontrolnyRetazec = (char *)malloc((velkost + 1) * sizeof(char));
	memset(kontrolnyRetazec, pismeno, (velkost)+1 * sizeof(char));
	kontrolnyRetazec[velkost] = '\0';
	i = hladaj(sekvencia, kontrolnyRetazec, 0);

	for (i; i < strlen(sekvencia);)
	{
		printf("%c %d\n", toupper(pismeno), i + 1);
		i = hladaj(sekvencia, kontrolnyRetazec, i + 1);
		if (i == -1)
		{
			break;
		}
	}
}

//pomocna funkcia na zistenie, ci sa sekvencia z pismen nachadza v retazci
int skontrolujStringy(char *str1, char pismeno, int inkrement)
{
	char *kontrolnyRetazec = (char *)malloc((strlen(str1) - inkrement + 1) * sizeof(char));
	memset(kontrolnyRetazec, pismeno, (strlen(str1) - inkrement + 1) * sizeof(char));
	kontrolnyRetazec[strlen(str1) - inkrement + 1] = '\0';
	if (strstr(str1, kontrolnyRetazec) != NULL)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

//funkcia na najdlhsi podretazec v sekvencii
void najdlhsiPodretazecVSekvencii(char *retazec)
{
	unsigned int i = 0;
	char *kontrolnyRetazec = NULL;
	char *skopirovanyRetazec = NULL;
	unsigned int velkost, c = 0, g = 0, a = 0, t = 0;

	if (retazec == NULL)
	{
		printf("Sekvencia nie je nacitana\n");
		return;
	}

	kontrolnyRetazec = (char *)malloc((strlen(retazec) + 1) * (sizeof(char)));
	skopirovanyRetazec = (char *)malloc((strlen(retazec) + 1) * (sizeof(char)));
	strcpy(skopirovanyRetazec, retazec);

	premenNaMalePismena(skopirovanyRetazec);

	for (i; i < strlen(retazec); i++)
	{	
		//nastavi nam vsetky hodnoty na dane pismo v sekvencii na N - i rozmedzi, cize ak je N 20 tak  20,19,18,17...
        //tym zistime, ze ake je najdlhsi retazec
		g = skontrolujStringy(skopirovanyRetazec, 'g', i);
		c = skontrolujStringy(skopirovanyRetazec, 'c', i);
		a = skontrolujStringy(skopirovanyRetazec, 'a', i);
		t = skontrolujStringy(skopirovanyRetazec, 't', i);

		
		if (a == 1 || c == 1 || g == 1 || t == 1)
		{
			break;
		}
		
		kontrolnyRetazec = (char *)malloc((strlen(retazec) - i + 1) * (sizeof(char)));
	}

	velkost = (strlen(retazec) - i + 1);

	free(kontrolnyRetazec);
	kontrolnyRetazec = NULL;
	kontrolnyRetazec = (char *)malloc((velkost + 1)* (sizeof(char)));
	printf("Najdlhsie useky opakujucich sa nukleotidov: %d\n", velkost);
	//najde vsetky pozicie, kde sa tie opakujuce sa veci nachadzaju
	if (c == 1)
	{
		najdiPozicie(skopirovanyRetazec, 'c', velkost);
	}
	if (a == 1)
	{
		najdiPozicie(skopirovanyRetazec, 'a', velkost);
	}
	if (t == 1)
	{
		najdiPozicie(skopirovanyRetazec, 't', velkost);
	}
	if (g == 1)
	{
		najdiPozicie(skopirovanyRetazec, 'g', velkost);
	}
}