using System;

using System.Web.Mvc;

using System.Linq;

using System.Collections.Generic;

​

namespace myMvcApp

{

    public class HomeController : Controller

    {

        [HttpGet]

        public ActionResult Index()

        {

        string prevInput ="Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua.";

        string afterInput =  "Lorem ipsum dolor sit amet,dolor consetetur sadipscing , sed diam nonumy tempor dolor invidunt ut labore et dolore magna erat sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren";

            return View(new myViewModel()

            {

            prev = prevInput,

            after =afterInput,

            items1 = EditSequenceLevensthein(prevInput, afterInput),

            items2 = CalculateDifferences(prevInput, afterInput)

            });

        }

​

 public static List<CharResult> CalculateDifferences(string before, string after)

        {

            List<char> barriers = new List<char>();

            int index = 0;

            for (int i = 0; i < after.Length; i++)

            {

                int match = before.IndexOf(after[i], index);

                if (match != -1)

                {

                    barriers.Add(after[i]);

                    index = match + 1;

                }

            }

            index = 0;

            List<CharResult> result = new List<CharResult>();

            foreach (char barrier in barriers)

            {

                int offsetBefore = before.IndexOf(barrier, index) - index;

                int offsetAfter = after.IndexOf(barrier, index) - index;

                if (offsetBefore > 0)

                {

                    result.AddRange(before.Substring(index, offsetBefore).Select(x => new CharResult() { c = x, state = CharState.Remove }));

                    before = before.Substring(offsetBefore);

                }

                if (offsetAfter > 0)

                {

​

                    string substring = after.Substring(index, offsetAfter);

                    result.AddRange(substring.Select(x => new CharResult() { c = x, state = CharState.Add }));

                    before = before.Insert(index, substring);

                    index += substring.Length;

                }

                result.Add(new CharResult() { c = barrier, state = CharState.Equal });

                index++;

            }

            if (index < before.Length)

            {

                result.AddRange(before.Substring(index).Select(x => new CharResult() { c = x, state = CharState.Remove }));

            }

            if (index < after.Length)

            {

                result.AddRange(after.Substring(index).Select(x => new CharResult() { c = x, state = CharState.Add }));

            }

            return result;

        }

​

​

        public static List<CharResult> EditSequenceLevensthein(string source, string target, int insertCost = 1, int removeCost = 1, int editCost = 2)

        {

            if (null == source)

                throw new ArgumentNullException("source");

            else if (null == source)

                throw new ArgumentNullException("target");

            // Forward: building score matrix

            // Best operation (among insert, update, delete) to perform 

            CharState[][] M = Enumerable.Range(0, source.Length + 1).Select(line => new CharState[target.Length + 1]).ToArray();

            // Minimum cost so far

            int[][] D = Enumerable.Range(0, source.Length + 1).Select(line => new int[target.Length + 1]).ToArray();

            // Edge: all removes

            for (int i = 1; i <= source.Length; ++i)

            {

                M[i][0] = CharState.Remove;

                D[i][0] = removeCost * i;

            }

​

            // Edge: all inserts 

            for (int i = 1; i <= target.Length; ++i)

            {

                M[0][i] = CharState.Add;

                D[0][i] = insertCost * i;

            }

​

            // Having fit N - 1, K - 1 characters let's fit N, K

            for (int i = 1; i <= source.Length; ++i)

                for (int j = 1; j <= target.Length; ++j)

                {

                    // here we choose the operation with the least cost

                    int insert = D[i][j - 1] + insertCost;

                    int delete = D[i - 1][j] + removeCost;

                    int edit = D[i - 1][j - 1] + (source[i - 1] == target[j - 1] ? 0 : editCost);

                    int min = Math.Min(Math.Min(insert, delete), edit);

                    if (min == insert)

                        M[i][j] = CharState.Add;

                    else if (min == delete)

                        M[i][j] = CharState.Remove;

                    else if (min == edit)

                        M[i][j] = CharState.Equal;

                    D[i][j] = min;

                }

​

            // Backward: knowing scores (D) and actions (M) let's building edit sequence

            List<CharResult> result = new List<CharResult>(Math.Max(source.Length, target.Length));

            for (int x = target.Length, y = source.Length; (x > 0) || (y > 0);)

            {

                CharState op = M[y][x];

                if (op == CharState.Add)

                {

                    x -= 1;

                    result.Add(new CharResult()

                    {state = CharState.Add, c = target[x]});

                }

                else if (op == CharState.Remove)

                {

                    y -= 1;

                    result.Add(new CharResult()

                    {c = source[y], state = CharState.Remove});

                }

                else if (op == CharState.Equal)

                {

                    x -= 1;

                    y -= 1;

                    if (source[y] == target[x])

                    {

                        result.Add(new CharResult()

                        {state = CharState.Equal, c = target[x]});

                    }

                    else

                    {

                        result.Add(new CharResult()

                        {state = CharState.Add, c = target[x]});

                        result.Add(new CharResult()

                        {state = CharState.Remove, c = source[y]});

                    }

                }

                else // <- Start

                    break;

            }

​

            result.Reverse();

            return result;

        }

    }

}