//Build the domain that generates the round robin schedule for the PRO-Kabaddi event that 

//conforms to the following constraints

//- Accept N number of teams

//- Each team must play against every other team once home and away

//- Maximum 2 matches per day are allowed

//- No team should play on consecutive days

​

//The solution should address the following aspects -

//0. Self sufficient project that can be tested and run 

//1. Must use best practices, design methodologies, patterns 

//2. Must use a dependency injection framework

//3. Must be unit tested

//4. May use ORM frameworks as required

​

​

​

using System;

using System.Collections.Generic;

​

public class Program {

​

    public static void Main(string[] args) {

​

        Console.WriteLine("Enter Team Count:");

​

        int iTeamsnew = 0;

        int iTeams = 0;

        if (!Int32.TryParse(Console.ReadLine(), out iTeamsnew)) {

            Console.WriteLine("Wrong input! Enter choice number again:");

        }

        else {

            iTeams = iTeamsnew;

        }

​

        Program prg = new Program();

        prg.PrepareMatches(iTeams);

​

    }

​

    private void PrepareMatches(int nTeams) {

        try {

            //Interface resolov for setting the Kabaddi matches

            ITournament trmnt = new ProKabaddiTournament();

            //Interface resolve for setting the Kabaddi matches with Constraints. This is using decorator pattern,

            ITournament trmntWithCons = new ProKabaddiTournamentWithConstraints();

​

​

            //Getting the Teams contest line up against each other using the base Tournament resolve

            List<Match> baseMatches = trmnt.PrepareMatches(nTeams);

​

​

            //pass the baseMatches to the Decorator class.

            trmntWithCons.BaseTournament = baseMatches;

            List<Match> matches = trmntWithCons.PrepareMatches(nTeams);

​

            //printing the schedule

            foreach (Match mth in matches) {

                Console.WriteLine(mth.MatchName + "  MatchDay_@Home: " + mth.MatchDayHome + "  MatchDay_@Away: " + mth.MatchDayAway);

​

            }

        }

        catch (Exception ex) {

            Console.WriteLine(ex.Message);

        }

    }

​

    public class Match {

        public string MatchName { get; set; }

        public int MatchDayHome { get; set; }

        public int MatchDayAway { get; set; }

        public int TeamA { get; set; }

        public int TeamB { get; set; }

​

    }

​

​

    //_________________________________________________________________________________________________

    //Interface for the Match Generator

    public interface ITournament {

        List<Match> BaseTournament { get; set; }

        List<Match> PrepareMatches(int nTeams);

​

    }

​

​

    //base Implementation of the ITournament

    public class ProKabaddiTournament : ITournament {

        private List<Match> sch;

​

        public List<Match> BaseTournament { get { return sch; } set { sch = value; } }

​

        public List<Match> PrepareMatches(int nTeams) {

            sch = new List<Match>();

            DrawMatches(nTeams);

            RemoveDummyTeamMatch(nTeams, ref sch);

            return sch;

        }

​

        private void RemoveDummyTeamMatch(int nTeams, ref List<Match> matches) {

            int teams = (nTeams % 2 == 1 ? nTeams + 1 : nTeams);

            if (teams > nTeams) {

                string dummyTeam = "Team" + teams.ToString();

​

                matches.RemoveAll(m => m.MatchName.Contains(dummyTeam) == true);

​

            }

​

        }

​

        private void DrawMatches(int nTeams) {

            try {

                int teams = (nTeams % 2 == 1 ? nTeams + 1 : nTeams);

​

                //create two arrays to hold SideA's and SideB's

                string[] sideA = new string[teams / 2];

                string[] sideB = new string[teams / 2];

                int y = 0;

                for (int i = 0; i < teams; i = i + 2) {

                    sideA[y] = "Team" + (i + 1).ToString();

                    sideB[y] = "Team" + (i + 2).ToString();

                    y++;

                }

​

                /*If there are N teams, there will be (N-2) rounds, each round comprising of N/2 matches where

                //with no team repeating their appearance within the round.

                Home matches*/

                for (int i = 0; i < teams - 1; i++) {

                    //iterate for each round

                    SetContest(teams, sideA, sideB);

                    if (teams > 2)

                        ReArrangeSides(teams / 2, ref sideA, ref sideB);

                }

            }

            catch (Exception ex) {

                Console.WriteLine(ex.Message);

            }

        }

​

        private void SetContest(int teams, string[] sideA, string[] sideB) {

            //for home

            for (int i = 0; i < (teams / 2); i++) {

                Match contest = new Match();

                contest.MatchName = sideA[i] + " vs " + sideB[i];

                contest.TeamA = Convert.ToInt32(sideA[i].Replace("Team", ""));

                contest.TeamB = Convert.ToInt32(sideB[i].Replace("Team", ""));

                sch.Add(contest);

            }

        }

​

        //Rearranging of the arrays needs to be done so the next set of matches can take place       

        private void ReArrangeSides(int size, ref string[] sideA, ref string[] sideB) {

            try {

                //pop the last element of the the array sideA and 

                string temp = sideA[size - 1];

                //move all but the first element 1 step down.

                for (int i = size - 1; i > 1; i--) {

                    sideA[i] = sideA[i - 1];

                }

                //now copy the first element of sideB to 2nd position on sideA

                sideA[1] = sideB[0];

                //move all the elements of arrayB now, one step up

                for (int i = 0; i < size - 1; i++) {

                    sideB[i] = sideB[i + 1];

                }

                //now move the last element of the sideA array to the last array of B

                sideB[size - 1] = temp;

            }

            catch (Exception ex) {

                Console.WriteLine(ex.Message);

            }

        }

    }

    public class ProKabaddiTournamentWithConstraints : ITournament {

        private List<Match> sch;

​

        public List<Match> BaseTournament { get { return sch; } set { sch = value; } }

        public List<Match> PrepareMatches(int nTeams) {

            List<Match> sch = this.sch;

            DrawMatchDays(nTeams, ref sch);

            return sch;

        }

​

​

        private void DrawMatchDays(int nTeams, ref List<Match> matches) {

            int[,] match_matrix = DrawDays(nTeams);

​

            foreach (Match match in matches) {

                int r = match.TeamA;

                int c = match.TeamB;

                match.MatchDayHome = match_matrix[r - 1, c - 1]; //Home matches

                match.MatchDayAway = match_matrix[c - 1, r - 1]; //Dummy matches

            }

        }

​

​

        private int[,] DrawDays(int nTeams) {

            int day_limit = nTeams < 7 ? 1 : 2;

            int n_matches = (nTeams * (nTeams - 1)) / 2;

            int[,] matches = new int[nTeams, nTeams];

            int curr_day_matches = 0;

            int m_day = 0;

            int done = 0;

            bool IsBreak = false;

            while (m_day <= n_matches + 10) {

                m_day++;

                curr_day_matches = 0;

                IsBreak = false;

                for (int r = 0; r < nTeams; r++) {

                    for (int c = r + 1; c < nTeams; c++) {

                        if (matches[r, c] == 0) {

                            if (IsAvailable(m_day, r, c, nTeams, ref matches)) {

                                matches[r, c] = m_day;

                                done++;

                                curr_day_matches++;

                                if (curr_day_matches == day_limit) {

                                    IsBreak = true;

                                    break;

                                }

                            }

                        }

                    }

                    if (IsBreak)

                        break;

                }

                if (done >= n_matches)

                    break;

​

            }

            for (int r = 0; r < nTeams; r++) {

                for (int c = 0; c < r; c++) {

                    if (r > c) {

                        matches[r, c] = matches[c, r] + m_day + 1; //1 day gap between the HOME and AWAY matches.

                    }

                }

            }

​

            return matches;

​

        }

​

        private bool IsAvailable(int day, int r, int c, int nTeams, ref int[,] matches) {

            bool res = true;

            int prev_day = day == 1 ? day : day - 1;

            for (int i = 0; i < nTeams; i++) {

​

                if (matches[i, c] == day || matches[i, c] == prev_day) {

                    res = false;

                    break;

                }

                else if (matches[c, i] == day || matches[c, i] == prev_day) {

                    res = false;

                    break;

                }

                else if (matches[r, i] == day || matches[r, i] == prev_day) {

                    res = false;

                    break;

                }

                else if (matches[i, r] == day || matches[i, r] == prev_day) {

                    res = false;

                    break;

                }

​

            }

            return res;

        }

    }

}