/****************************************************************************
* Filename: slast.h
* Original Author: Faith E. Olusegun (propenster)
* File Creation Date: December 2nd, 2023
* Description: SLAST functions, definitions  - header
* LICENSE: MIT
*************************************************************************************/

#pragma once
#ifndef SLAST_H

#define SLAST_H

/// this could be customized
#define MATCH_SCORE 2
#define MISMATCH_SCORE -1
#define GAP_PENALTY -1

int max_of(int a, int b, int c);

int calculateScore(char a, char b);
void simpleLocalAlignment(char* seq1, char* seq2);



#endif //SLAST_H#pragma once

/****************************************************************************
* Filename: slast.c
* Original Author: Faith E. Olusegun (propenster)
* File Creation Date: December 2nd, 2023
* Description: SLAST functions, definitions and implementation details
* LICENSE: MIT
*************************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "slast.h"

/// @brief 
/// @param a - 
/// @param b 
/// @param c 
/// @return 
///
int max_of(int a, int b, int c) {
    int max_of_ab = (a > b) ? a : b;
    return (max_of_ab > c) ? max_of_ab : c;
}

/// @brief calculates match/alignment Score
/// @param a first nucleotide (a) to be compared to another (b)
/// @param b second nucleotide (b) to be compared with a
/// @return match or mismatch score
int calculateScore(char a, char b) {
    return (a == b) ? MATCH_SCORE : MISMATCH_SCORE;
}

/// @brief performs the local alignment
/// @param seq1 sequence 1
/// @param seq2 sequence 2 or reference sequence
void simpleLocalAlignment(char* seq1, char* seq2) {
    size_t len1 = strlen(seq1);
    size_t len2 = strlen(seq2);
    //create our dp matrix and allocate memory for it...
    //we will use it to store scores as we compute
    int** dp = (int**)malloc((len1 + 1) * sizeof(int*));
    for (size_t i = 0; i < len1; ++i) {
        dp[i] = (int*)malloc((len2 + 1) * sizeof(int));
    }

    int maxScore = 0;
    int endRow, endCol = 0;

    //init alignment matrix
    for (size_t row = 0; row < len1; ++row) {
        for (size_t col = 0; col < len2; ++col) {
            if (row == 0 || col == 0) {
                
                if (row <= len1 && col <= len2) {
                    dp[row][col] = 0;
                }
                else {
                    return 1;
                }
            }
            else {
                int match = dp[row - 1][col - 1] + calculateScore(seq1[row - 1], seq2[col - 1]);
                int delete = dp[row - 1][col] + GAP_PENALTY;
                int insert = dp[row][col - 1] + GAP_PENALTY;
                dp[row][col] = max(match, delete, insert);

                if (dp[row][col] > maxScore) {
                    maxScore = dp[row][col];
                    endRow = row;
                    endCol = col;
                }
            }
        }
    }

    //find && print new alignment
    int i = endRow;
    int j = endCol;
    while (i > 0 && j > 0 && dp[i][j] != 0) {
        int score = dp[i][j];
        int diagonal = dp[i - 1][j - 1];
        int left = dp[i][j - 1];
        int up = dp[i - 1][j];

        if (score == diagonal + calculateScore(seq1[i - 1], seq2[j - 1])) {
            printf("%c", seq1[i - 1]);
            i--;
            j--;
        }
        else if (score == up + GAP_PENALTY) {
            printf("-"); //
            i--;
        }
        else {
            printf("-");
            j--;
        }

    }

    //free
    for (size_t i = 0; i < len1; ++i) {
        free(dp[i]);
    }

    free(dp);


}

/****************************************************************************
* Filename: main.c
* Original Author: Faith E. Olusegun (propenster)
* File Creation Date: December 2nd, 2023
* Description: Entry to SLAST Dynamic programming-based sequence alignment algorithm
* LICENSE: MIT
*************************************************************************************/


#include <stdio.h>
#include "slast.h"

int main(int argc, char const* argv[])
{
    printf("Welcome to SLAST (Simple Local Alignment Search Tool in C\n");

    char seq1[] = "ACTCCGAT";
    char seq2[] = "GCTAAGAT";

    printf("Sequence 1 to be aligned: %s\n", seq1);
    printf("Sequence 1 to be aligned: %s\n", seq2);

    printf("Alignment: \n");

    simpleLocalAlignment(seq1, seq2);

    return 0;
}

int value = 50;
var option = new Some<int>(value);
Console.WriteLine(option?.ValueOrDefault());

Assert.Equal(value, option?.ValueOrDefault());
Assert.NotNull(option);
Assert.IsType<Some<int>>(option);
Assert.IsType<int>(option?.ValueOrDefault());

var noneReturningOption = new None<int>();
Assert.NotNull(noneReturningOption);
Assert.Equal(0, noneReturningOption?.ValueOrDefault());
Assert.Equal(0, noneReturningOption?.Value);
Assert.Equal(false, noneReturningOption?.IsSome());
Assert.Equal(true, noneReturningOption?.IsNone());
Assert.IsType<None<int>>(noneReturningOption);
//it doesn't lose it's enclosed primitive type though it still came as None
Assert.IsType<int>(noneReturningOption?.ValueOrDefault()); 
Assert.IsAssignableFrom<int>(noneReturningOption?.ValueOrDefault());

private static Option<decimal> DecimalReturningOptionMethod()
{
decimal d = decimal.MaxValue;
return new Some<decimal>(d);
}

private Option<Person> GetPerson_Some_Or_None()
{
var person = new Person { Name = "Willelm Rudenmalm", Age = 28 };
return new Some<Person>(person) ?? new None<Person>();
}

var option = new None<int>();
Assert.Throws<Exception>(() => option.ValueOrError("Error could not retrieve item , item is null or default"));

var option = new None<int>();
Assert.Throws<MyCustomException>(() => option.ValueOrError(() => throw new MyCustomException("Error could not find item")));

var option = new Some<double>(2.58);
if(option.IsSome()){
Console.WriteLine($"Option is Some and it's value is {option.ValueOrDefault()}");
//OR destroy everything.
//without saying, this throws a bomb (an Exception) if option is None<T>
var valueOrMakeAMess = option.ValueOrError("This double is supposed to be here now I'm going to have to throw an exception"); 
//OR pass an Exception callback with your own customer Exception
//without saying, this throws a bomb (a YourMessyCustomException) if option is None<T>
var valueOrMakeAMess = option.ValueOrError(() => throw new YourMessyCustomException("You must never not have this double")); 
}else{
Console.WriteLine("Option is None");
}