using System;

using System.Collections.Generic;

using System.Linq;

public abstract class PersistableEntity

{

    public int Id {get;set;}

}

​

public abstract class NonPersistableEntity

{

}

​

public class Scheme : PersistableEntity

{

    public string AdministratorName {get;set;}

}

​

public class PSRAnswerSet : PersistableEntity

{

    public PSRScheme PSRScheme {get;set;}

    public bool Q1 {get;set;}

    public bool Q2 {get;set;}

    public bool Q3 {get;set;}

    public bool Q4 {get;set;}

    public bool Q5 {get;set;}

    public bool Q6 {get;set;}

    public decimal? Q7 {get;set;}

    public string Q14AdministratorName {get;set;}

}

​

public class PSRScheme : PersistableEntity

{

    public Scheme Scheme {get;set;}

    public PSR PSR {get;set;}

    public PSRAnswerSet PSRAnswerSet {get;set;}

}

​

public class PSR : PersistableEntity

{

    public PSR()

    {

        this.PSRSchemes = new List<PSRScheme>();

    }

    public List<PSRScheme> PSRSchemes {get;set;}    

}

​

public interface IPlatinumRepository : IDisposable

{

    IList<Scheme> Schemes {get;}    

    IList<PSR> PSRs {get;}

    IList<PSRScheme> PSRSchemes {get;}

    IList<PSRAnswerSet> PSRAnswerSets {get;}

}

​

public class PlatinumContext : IPlatinumRepository

{

    private PlatinumContext()

    {}

    private static PlatinumContext _singleton;

    public static PlatinumContext Instance()

    {

        if (_singleton == null)

        {

            _singleton = new PlatinumContext();

        }

        return _singleton;

    }

    public List<Scheme> SchemeList = new List<Scheme>();

    public List<PSR> PSRList = new List<PSR>();

    public List<PSRScheme> PSRSchemeList = new List<PSRScheme>();

    public List<PSRAnswerSet> PSRAnswerSetList = new List<PSRAnswerSet>();

    public IList<Scheme> Schemes {get{return this.SchemeList;}} 

    public IList<PSR> PSRs {get{return this.PSRList;}}

    public IList<PSRScheme> PSRSchemes {get {return this.PSRSchemeList;}}

    public IList<PSRAnswerSet> PSRAnswerSets {get{return this.PSRAnswerSetList;}}   

    public void Dispose()

    {

    }

    public void SaveChanges()

    {

        Console.WriteLine("\tRepository: SaveChanges called");

    }

}

​

public abstract class Handler<TContext>

{

    protected Handler<TContext> Subsequent {get;private set;}

    protected Handler(Handler<TContext> subsequent)

    {

        this.Subsequent = subsequent;

    }

    protected abstract void InternalExecute(TContext context);

    public void Execute(TContext context)

    {

        Console.WriteLine("\tHandler:Execute called ({0})", this.GetType().Name);

        InternalExecute(context);

        if (this.Subsequent != null)

        {

            this.Subsequent.Execute(context);

        }

    }   

}

​

public class PSRAnswerHandlerContext

{

    public PSR PSR {get;set;}

    public IPlatinumRepository Repository {get;set;}

}

​

public abstract class PSRAnswerHandler : Handler<PSRAnswerHandlerContext>

{

    protected PSRAnswerHandler(PSRAnswerHandler subsequent) : base(subsequent)

    {

    }

}

​

public class SSASPSRAnswerHandlerForAllQuestions : PSRAnswerHandler

{

    public SSASPSRAnswerHandlerForAllQuestions(PSRAnswerHandler subsequent) : base(subsequent){}

    protected override void InternalExecute(PSRAnswerHandlerContext context)

    {

        var repository = context.Repository;

​

        foreach(var psrScheme in repository.PSRSchemes.Where(x=>x.PSR == context.PSR))

        {

            var psrAnswerSet = new PSRAnswerSet{PSRScheme = psrScheme};

            psrScheme.PSRAnswerSet = psrAnswerSet;

            repository.PSRAnswerSets.Add(psrAnswerSet);

        }

    }

}

​

public class SSASPSRAnswerHandlerForQ1_Q2_Q3 : PSRAnswerHandler

{

    public SSASPSRAnswerHandlerForQ1_Q2_Q3(PSRAnswerHandler subsequent) : base(subsequent){}

    protected override void InternalExecute(PSRAnswerHandlerContext context)

    {

    }

}

​

public class SSASPSRAnswerHandlerForQ4 : PSRAnswerHandler

{

    public SSASPSRAnswerHandlerForQ4(PSRAnswerHandler subsequent) : base(subsequent){}

    protected override void InternalExecute(PSRAnswerHandlerContext context)

    {

    }

}

​

public class GenerateXML : PSRAnswerHandler

{

    public GenerateXML(PSRAnswerHandler subsequent) : base(subsequent){}

    protected override void InternalExecute(PSRAnswerHandlerContext context)

    {

    }

}

​

public class ValidateXML : PSRAnswerHandler

{

    public ValidateXML(PSRAnswerHandler subsequent) : base(subsequent){}

    protected override void InternalExecute(PSRAnswerHandlerContext context)

    {

    }

}

​

public class PSRSubmitHandlerContext

{

    public PSR PSR {get;set;}

    public IPlatinumRepository Repository {get;set;}

}

​

public abstract class PSRSubmitHandler : Handler<PSRSubmitHandlerContext>

{

    protected PSRSubmitHandler(PSRSubmitHandler subsequent) : base(subsequent)

    {

    }

}

​

public class TransmitXML : PSRSubmitHandler

{

    public TransmitXML(PSRSubmitHandler subsequent) : base(subsequent)

    {

    }

    protected override void InternalExecute(PSRSubmitHandlerContext context)

    {

    }   

}

​

public interface IReporting

{

    void PSRGather(int id);

    void PSRSubmit(int id);

}

​

public interface IEnrollment

{

}

​

public class ApiFacade : IReporting, IEnrollment

{

    public void PSRGather(int id)

    {

        using(var repository = PlatinumContext.Instance())

        {

            var psr = repository.PSRs.Single(x=>x.Id == id);

            var workflow = new PSROrchestration();

            workflow.Gather(psr, repository);

            repository.SaveChanges();

        }       

    }

    public void PSRSubmit(int id)

    {

        using(var repository = PlatinumContext.Instance())

        {

            var psr = repository.PSRs.Single(x=>x.Id == id);

            var workflow = new PSROrchestration();

            workflow.Submit(psr, repository);

            repository.SaveChanges();

        }               

    }

}

​

public class PSROrchestration : NonPersistableEntity

{

    public void Gather(PSR psr, IPlatinumRepository repository)

    {           

        var ctx = new PSRAnswerHandlerContext {Repository = repository, PSR = psr};

        GetSSASAnswerGatherHandlers().Execute(ctx); 

    }

    public void Submit(PSR psr, IPlatinumRepository repository)

    {

        var ctx = new PSRSubmitHandlerContext {Repository = repository, PSR = psr};

        GetSubmitHandlers().Execute(ctx);   

    }

    private PSRAnswerHandler GetSSASAnswerGatherHandlers()

    {

        return new SSASPSRAnswerHandlerForAllQuestions(

                new SSASPSRAnswerHandlerForQ1_Q2_Q3(

                    new SSASPSRAnswerHandlerForQ4(

                        new GenerateXML(

                            new ValidateXML(null)))));

    }

    private PSRSubmitHandler GetSubmitHandlers()

    {

        return new TransmitXML(null);

    }   

}

​

public class Program

{

​

    public static void Main()

    {

        // Get access to the one and only instance of the repository (implemented here as a singleton for convenience)

        var repository = PlatinumContext.Instance();

​

        // Setup background data...     

        var ssas = new Scheme();

        repository.SchemeList.Add(ssas);

        var psr = new PSR{Id=69};

        repository.PSRList.Add(psr);

        var psrScheme = new PSRScheme{PSR = psr, Scheme = ssas};

        repository.PSRSchemeList.Add(psrScheme);

        // IReporting is one of resources, in terms of REST, supported by the (public) API 

        // ApiFacade = PlatinumModelFacade

        // PlatinumModelFacade is responsible for creating reference to repository

        IReporting reporting = new ApiFacade();

        Console.WriteLine("Start gather...");

        reporting.PSRGather(psr.Id);    

        Console.WriteLine("Start submit...");

        reporting.PSRSubmit(psr.Id);

    }

}