using BeWo.Report;
using BeWo.Service.Plugins;
using BeWo.View.Navigation.Filter;
using BeWoPlanerMobil.Models;
using BeWoPlanerMobil.Service;
using BeWoPlanerMobil.Util;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web.Mvc;

// Controller des Auswertungsmoduls
namespace BeWoPlanerMobil.Controllers
{
    public class ReportViewerController : ReportBaseController
    {
        private ReportViewerModel _Model;

        public ReportViewerModel Model
        {
            get
            {
                if(false == MobileSessionFacade.IsUserLoggedIn())
                {
                    RedirectToActionPermanent("Index", "Login");
                    return null;
                }


                if(_Model is null)
                {
                    _Model = new ReportViewerModel { ReportCreator = GetReportCreator() };
                    InitModel(_Model);
                    InitViewModel();
                }

                return _Model;
            }
        }

        private void InitViewModel()
        {
            Model.Report = null;

            var month = DateTime.Today.Month;
            var year = DateTime.Today.Year;
            var first = new DateTime(year, month, 1).AddMonths(-1);

            Model.SelectedYear = Model.SelectedYear ?? first.Year;
            Model.SelectedMonth = Model.SelectedMonth ?? first.Month;



            Model.AllEmployees = Model.HasRightMitarbeiterstundenkontoViewAll
                ? EmployeeService.GetAllActiveEmployeesCompact()
                : new List<CompactEmployeeDC> { LoggedInUser.Employee };

            // Alle Teams darf man nur sehen, wenn man das Recht "HasRightMitarbeiterstundenkontoViewAll" hat.
            // Hat man weder das Recht "HasRightMitarbeiterstundenkontoViewAll" noch "HasRightMitarbeiterstundenkontoViewTeams", sieht man die Teams gar nicht.
            // Hat man das Recht "HasRightMitarbeiterstundenkontoViewTeams", aber nicht das Recht "HasRightMitarbeiterstundenkontoViewAll", sieht man nur die Teams, deren Teamleiter man ist.

            Model.AllTeams = Model.HasRightMitarbeiterstundenkontoViewAll
                ? EmployeeService.GetAllActiveCompactTeamsForEmployee(LoggedInEmployee.EmployeeOid)
                : EmployeeService.FindLeadingCompactTeamsOfEmployee(LoggedInUser.Employee.EmployeeOid);

            if (false == Model.HasRightMitarbeiterstundenkontoViewAll || Model.SelectedEmployeeOid is null)
            {
                Model.SelectedEmployeeOid = LoggedInUser.Employee.EmployeeOid;
            }

            if (Model.SelectedEmployeeOid.HasValue)
            {
                Model.SelectedEmployee = Model.AllEmployees.FirstOrDefault(employee => employee.EmployeeOid.Equals(Model.SelectedEmployeeOid.Value));
            }

            if (Model.SelectedTeamOid.HasValue)
            {
                Model.SelectedTeam = Model.AllTeams.FirstOrDefault(team => team.TeamOid.Equals(Model.SelectedTeamOid.Value));
            }



            Model.ReportTypes = new List<SelectListItem>();

#if DEBUG
            if (Model.HasRightToViewReports)
            {
                Model.ReportTypes.Add(new SelectListItem
                {
                    Text = "Berichte",
                    Value = "0"
                });

                Model.AllEmployeesForQueries = EmployeeService.GetAllActiveEmployeesCompact();
                Model.AllCustomersForQueries = EmployeeService.GetActiveCompactCustomersForEmployee(null);

                Model.Queries = QueryService.GetAllQueriesOfType(QueryType.Public);

                if (Model.SelectedQueryOid.HasValue)
                {
                    Model.SelectedQuery = Model.Queries.FirstOrDefault(q => q.Oid.Equals(Model.SelectedQueryOid.Value));
                }

                var names2ValueListEntryTypes = new Dictionary<string, ValueListEntryType>();

                foreach (var query in Model.Queries.Where(q => q.Parameter?.Any() ?? false))
                {
                    foreach (var parameter in query.Parameter.Where(p => p.ParamType == QueryParameterType.ValueListEntryType))
                    {
                        var parameterName = parameter.Name;

                        if (!(parameterName?.Contains("_") ?? false))
                        {
                            continue;
                        }

                        var name2Type = parameterName.Split('_');

                        var name = name2Type[0];
                        var type = name2Type[1];

                        if (!int.TryParse(type, out var typeEnumInt))
                        {
                            continue;
                        }

                        var valueListEntryType = (ValueListEntryType)typeEnumInt;
                        names2ValueListEntryTypes.AddIfNotIn(new KeyValuePair<string, ValueListEntryType>(name, valueListEntryType));
                    }
                }

                Model.AllValueListEntriesForQuery = ValueListService.GetAllValueListEntrysByTypes(names2ValueListEntryTypes.Values.ToList()).ToList();

                Model.AllValueListEntriesForQuery.DoForEach(valueListEntry =>
                {
                    Model.ValueListEntryTypes2ValueListEntries.AddOrUpdateValueInDictionary(valueListEntry.Type, valueListEntry);
                });

                if (Model.LoggedInEmployee?.EmployeeOid.HasValue ?? false)
                {
                    Model.SupportConcepts = EmployeeService.GetActiveSupportConceptsForEmployee(Model.LoggedInEmployee.EmployeeOid, CustomerFilterEnum.All);
                }
                else
                {
                    Model.SupportConcepts = new List<SupportConceptDC>();
                }

                Model.SupportConcepts.DoForEach(sc => Model.CostBearer2SupportConceptRels.AddRangeIfElementsNotIn(sc.CostBearerRelations));

                if (Model.SelectedCostBearer2SupportConceptRelListObject is null)
                {
                    Model.SelectedCostBearer2SupportConceptRelListObject = Model.CostBearer2SupportConceptRelListObjects.FirstOrDefault(f => f.CostBearer2SupportConceptOid == -1) ?? Model.CostBearer2SupportConceptRelListObjects.First();
                }

                Model.AllOrganisationForQuery = CustomerService.GetAllActiveOrganisationsCompact();
                Model.AllTeamsForQueries = EmployeeService.GetAllActiveCompactTeamsForEmployee(null);

                Model.AllServiceCategoriesForQueries = OperationsService.GetAllServiceCategories();
            }
#endif

            if (Model.HasRightToViewMitarbeiterstundenkonto)
            {
                Model.ReportTypes.Add(new SelectListItem
                {
                    Text = "Mitarbeiterstundenkonto",
                    Value = "1"
                });
            }
#if !DEBUG
            Model.SelectedReportType = ReportType.Mitarbeiterstundenkonto;
#endif

#if DEBUG
            //Model.SelectedReportType = ReportType.Berichte;
#endif
        }

        [Authorize]
        public ActionResult ReportViewer()
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return Logout();
            }

            return View(Model);
        }

        [Authorize]
        public ActionResult DocumentWebViewerPartial()
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
            }

            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        public ActionResult LoadCustomReport(long? reportOid)
        {
            try
            {
                if(Model?.LoggedInEmployee?.EmployeeOid is null || reportOid is null)
                {
                    TempData[TempDataConstants.DoLogoutKey] = true;
                    return PartialView("BeWoReportPartial");
                }

                var selectedQuery = Model.Queries.FirstOrDefault(query => query.Oid.Equals(reportOid.Value));

                if(selectedQuery is null)
                {
                    Model.Report = null;
                    return PartialView("BeWoReportPartial", Model);
                }

                Model.SelectedCustomReport = Model.CustomReports.FirstOrDefault(cr => cr.QueryOid == selectedQuery.Oid);

                Model.SelectedQuery = selectedQuery;

                var dcid = $"{MobileSessionFacade.Tenant}queryeoid{Model.LoggedInEmployee.EmployeeOid.Value}";

                var queryResult = QueryService.ExecuteQuery(selectedQuery.Oid, null);
                
                if(queryResult is null)
                {
                    return PartialView("BeWoReportPartial", Model);
                }

                QueryService.PrepareQueryReport(queryResult, dcid);
                var queryReport = Model.ReportCreator.CreateQueryReport(selectedQuery.Oid, dcid);

                Model.Report = queryReport;
                Model.ReportName = selectedQuery.Title;
            }
            catch(Exception e)
            {
                Log.Error(e);
                if(Model != null)
                {
                    Model.ReportName = "Fehler";
                }
                TempData[TempDataConstants.ReportErrorMessageKey] = e.Message;
            }

            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        public ActionResult LoadBerichteForm(long? reportOid)
        {
            try
            {
                if(Model?.LoggedInEmployee?.EmployeeOid is null || reportOid is null)
                {
                    TempData[TempDataConstants.DoLogoutKey] = true;
                    return PartialView("BerichteFormPartialView");
                }

                var selectedQuery = Model.Queries.FirstOrDefault(query => query.Oid.Equals(reportOid.Value));

                if(selectedQuery is null)
                {
                    return PartialView("BerichteFormPartialView", Model);
                }

                Model.SelectedCustomReport = Model.CustomReports.FirstOrDefault(cr => cr.QueryOid == selectedQuery.Oid);
                Model.SelectedQueryOid = selectedQuery.Oid;
                Model.SelectedQuery = selectedQuery;

                foreach(var parameter in selectedQuery?.Parameter ?? new List<QueryParamDC>())
                {
                    if(parameter.QueryParameterOid is null)
                    {
                        continue;
                    }

                    if(parameter.ParamType == QueryParameterType.Year)
                    {
                        Model.SelectedValues.AddOrUpdate(parameter.QueryParameterOid.Value, new SelectedValue(QueryParameterType.Year, DateTime.Today.Year));
                    }

                    if(parameter.ParamType == QueryParameterType.Month)
                    {
                        Model.SelectedValues.AddOrUpdate(parameter.QueryParameterOid.Value, new SelectedValue(QueryParameterType.Month, DateTime.Today.AddMonths(-1)));
                    }
                }

                

                return PartialView("BerichteFormPartialView", Model);
            }
            catch(Exception exception)
            {
                Log.Error(exception);
                TempData[TempDataConstants.ReportErrorMessageKey] = exception.Message;
            }

            return PartialView("BerichteFormPartialView", Model);
        }

        private string GetSiteOfOrigin()
        {
            if(Model?.LoggedInEmployee?.EmployeeOid is null)
            {
                return null;
            }

            var url = Request?.Url;

#if DEBUG
            return "http://localhost:3777/Host";
#endif

            return $"{url.Scheme}://{url.Host}/service";
        }

        [Authorize]
        public ActionResult LoadViewerForm(string reportType)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("ReportViewerFormPartial");
            }

            Model.SelectedReportType = reportType == "0" ? ReportType.Berichte : ReportType.Mitarbeiterstundenkonto;
            
            return PartialView("ReportViewerFormPartial", Model);
        }

        [Authorize]
        public string SetEmployeeForMitarbeiterstundenkonto(long? employeeOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return LeerzeichenFuerGetMethoden;
            }

            if(employeeOid is null)
            {
                Model.SelectedEmployee = null;
                return LeerzeichenFuerGetMethoden;
            }

            Model.SelectedEmployeeOid = employeeOid;
            Model.SelectedEmployee = Model.AllEmployees.FirstOrDefault(employee => employee.EmployeeOid.Equals(employeeOid.Value));

            return Model.SelectedEmployee?.DetailDescription ?? LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string SetTeamForMitarbeiterstundenkonto(long? teamOid)
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return LeerzeichenFuerGetMethoden;
            }

            if(teamOid is null)
            {
                Model.SelectedTeam = null;
                return LeerzeichenFuerGetMethoden;
            }

            Model.SelectedTeamOid = teamOid;
            Model.SelectedTeam = Model.AllTeams.FirstOrDefault(team => team.TeamOid.Equals(teamOid.Value));

            return Model.SelectedTeam?.DetailDescription ?? LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public ActionResult LoadMitarbeiterstundenkonto(int ansicht, int month, int year, bool all, bool isEmployee)
        {
            if(Model?.LoggedInEmployee?.EmployeeOid is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BeWoReportPartial");
            }

            var teamOids = new List<long>();
            var employeeOid = Model.SelectedEmployeeOid;
            var oid = isEmployee ? employeeOid ?? Model.LoggedInEmployee.EmployeeOid.Value : Model.SelectedTeamOid;

            if(isEmployee)
            {
                teamOids = null;
                employeeOid = oid;

                if(all || false == Model.HasRightMitarbeiterstundenkontoViewAll)
                {
                    employeeOid = null;
                }

                if(employeeOid.HasValue)
                {
                    employeeOid = oid;
                }

                if(false == Model.HasRightMitarbeiterstundenkontoViewAll)
                {
                    employeeOid = Model.LoggedInEmployee.EmployeeOid;
                }
            }
            else
            {
                employeeOid = null;

                var teamOid = oid;

                if(all || (!Model.HasRightMitarbeiterstundenkontoViewAll && !Model.HasRightMitarbeiterstundenkontoViewTeams))
                {
                    teamOid = null;
                }

                if(teamOid != null)
                {
                    teamOid = oid;
                }

                if(teamOid > 0 && !all)
                {
                    teamOids.Add(teamOid.Value);
                }
                else if(all)
                {
                    teamOids.AddRange(Model.AllTeams.Select(team => team.TeamOid));
                }
            }

            var start = new DateTime(year, month, 1);
            var end = start.AddMonths(1);

            Model.Report = Model.ReportCreator.CreateEmployeeHourReport(employeeOid, teamOids, start, end, ansicht);

            return PartialView("BeWoReportPartial", Model);
        }

        private static AbstractReportCreator GetReportCreator()
        {
            AbstractReportCreator creator = PluginLoader.FindClass<DefaultReportCreator>() ?? new DefaultReportCreator();

            var mobileBaseDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\Host\");
#if DEBUG
            creator.TempPath = BS.Shared.Core.Utils.CreateSavePath(mobileBaseDirectory, @"demo\temp");
#else
			creator.TempPath = BS.Shared.Core.Utils.CreateSavePath(mobileBaseDirectory, PluginLoader.Tenant + @"\temp");
#endif
            return creator;
        }

        [Authorize]
        public override string ResetReport()
        {
            if(Model is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return LeerzeichenFuerGetMethoden;
            }

            Model.Report = null;
            Model.ReportName = null;

            return LeerzeichenFuerGetMethoden;
        }

        // ToDo: Parameter hinzufügen
        [Authorize]
        public ActionResult CreateBerichtWithParameters()
        {
            if(Model?.SelectedQuery is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BeWoReportPartial");
            }



            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        public ActionResult SelectCostBearer2SupportConceptRel(long? relOid)
        {
            if(Model?.SelectedQuery is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BerichteFormPartialView", Model);
            }

            if(relOid != null)
            {
                Model.SelectedCostBearer2SupportConceptRelListObject = Model.CostBearer2SupportConceptRelListObjects.FirstOrDefault(f => f.CostBearer2SupportConceptOid != null && f.CostBearer2SupportConceptOid.Equals(relOid.Value.ToString()));
            }

            return PartialView("BerichteFormPartialView", Model);
        }

        [Authorize]
        public ActionResult SelectQueryCustomValue(string customValue, long? paramOid)
        {
            if(Model?.SelectedQuery is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BerichteFormPartialView");
            }

            return PartialView("BerichteFormPartialView", Model);
        }

        [Authorize]
        public ActionResult SelectValueListEntry(long? valueListEntryOid, int paramType, int index)
        {
            if(Model?.SelectedQuery is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BerichteFormPartialView");
            }

            if(valueListEntryOid.HasValue)
            {
                var type = (QueryParameterType)paramType;
                var valueListEntry = Model.AllValueListEntriesForQuery.FirstOrDefault(vle => vle.ValueListEntryOid.HasValue && vle.ValueListEntryOid.Value.Equals(valueListEntryOid));

                if(valueListEntry != null)
                {
                    var selectedValue = new SelectedValue(type, valueListEntry);

                    Model.SelectedValues.AddOrUpdate(index, selectedValue);
                }
            }

            return PartialView("BerichteFormPartialView", Model);
        }

        [Authorize]
        public ActionResult SelectQueryParameter(long? objectOid, int parameterType, long? parameterOid, string textValue)
        {
            if(Model?.SelectedQueryOid.HasValue ?? false)
            {
                Model.SelectedQuery = Model.Queries.FirstOrDefault(q => q.Oid.Equals(Model.SelectedQueryOid.Value));
            }

            if(Model?.SelectedQuery is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;
                return PartialView("BerichteFormPartialView");
            }

            if(parameterOid.HasValue)
            {
                var queryParameterType = (QueryParameterType) parameterType;

                switch(queryParameterType)
                {
                    case QueryParameterType.Custom:
                        throw new NotImplementedException("Dieser Parametertyp wird noch nicht unterstützt!");
                    case QueryParameterType.Customer:
                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryCustomerOids.Remove(parameterOid.Value);
                            break;
                        }

                        var selectedCustomer = Model.AllCustomersForQueries.FirstOrDefault(customer => customer.CustomerOid.Equals(objectOid.Value));
                        
                        if(selectedCustomer is object)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedCustomer));
                            Model.QueryCustomerOids.AddOrUpdate(parameterOid.Value, selectedCustomer.CustomerOid);
                        }
                    break;
                    case QueryParameterType.Employee:
                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryEmployeeOids.Remove(parameterOid.Value);
                            break;
                        }

                        var selectedEmployee = Model.AllEmployeesForQueries.FirstOrDefault(employee => employee.EmployeeOid.Equals(objectOid.Value));
                        
                        if(selectedEmployee != null)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedEmployee));
                            Model.QueryEmployeeOids.AddOrUpdate(parameterOid.Value, selectedEmployee.EmployeeOid);
                        }
                    break;
                    case QueryParameterType.Organisation:
                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryOrganisationOids.Remove(parameterOid.Value);
                            break;
                        }

                        var selectedOrganisation = Model.AllOrganisationForQuery.FirstOrDefault(organisation => organisation.OrganisationOid.Equals(objectOid.Value));

                        if(selectedOrganisation != null)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedOrganisation));
                            Model.QueryOrganisationOids.AddOrUpdate(parameterOid.Value, selectedOrganisation.OrganisationOid);
                        }
                    break;
                    case QueryParameterType.Text:
                        if(false == string.IsNullOrEmpty(textValue)) 
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, textValue));
                            Model.QueryTexts.AddOrUpdate(parameterOid.Value, textValue);
                        }
                        else
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryTexts.Remove(parameterOid.Value);
                        }

                    break;
                    case QueryParameterType.Date:
                        if(textValue != null && DateTime.TryParse(textValue, out var selectedDate))
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedDate));
                            Model.QueryDateTimes.AddOrUpdate(parameterOid.Value, selectedDate);
                        }
                        else
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryDateTimes.Remove(parameterOid.Value);
                        }

                    break;
                    case QueryParameterType.DateRange:
                        if(textValue != null && textValue.Length == 21 &&textValue.Contains("_"))
                        {
                            var split = textValue.Split('_');
                            if(DateTime.TryParse(split[0], out var start) && DateTime.TryParse(split[1], out var end))
                            {
                                var dateRange = new DateTimeSpan(start, end);
                                Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, dateRange));
                                Model.QueryDateRanges.AddOrUpdate(parameterOid.Value, dateRange);
                            }
                        }
                        else
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryDateRanges.Remove(parameterOid.Value);
                        }
                    break;
                    case QueryParameterType.Month:
                        if(!textValue.Contains("_"))
                        {
                            break;
                        }

                        var month2Year = textValue.Split('_');
                        var monthAsString = month2Year[0];
                        var yearAsString = month2Year[1];

                        if(int.TryParse(monthAsString, out var month) && month > 0 && month < 13 && int.TryParse(yearAsString, out var year) && Model.Years.Any(listItem => listItem.Value.Equals(yearAsString)))
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, new DateTime(year, month, 1)));
                            Model.QueryMonths.AddOrUpdate(parameterOid.Value, new DateTime(year, month, 1));
                        }
                    break;
                    case QueryParameterType.ServiceCategory:
                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryServiceCategoryOids.Remove(parameterOid.Value);
                            break;
                        }

                        var selectedServiceCategory = Model.AllServiceCategoriesForQueries.FirstOrDefault(serviceCategory => serviceCategory.ServiceCategoryOid.HasValue && serviceCategory.ServiceCategoryOid.Value.Equals(objectOid));

                        if(selectedServiceCategory != null)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedServiceCategory));
                            Model.QueryServiceCategoryOids.AddOrUpdate(parameterOid.Value, selectedServiceCategory.ServiceCategoryOid.Value);
                        }
                    break;
                    case QueryParameterType.SupportConcept:
                        var costBearer2SupportConceptRelListObj = Model.CostBearer2SupportConceptRelListObjects.FirstOrDefault(costBearer2SupportConceptRelListObject => costBearer2SupportConceptRelListObject.CostBearer2SupportConceptOid.Equals(objectOid.ToString()));

                        Model.SelectedCostBearer2SupportConceptRelListObject = costBearer2SupportConceptRelListObj;

                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QuerySupportConceptOids.Remove(parameterOid.Value);
                            break;
                        }

                        if(costBearer2SupportConceptRelListObj != null)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, costBearer2SupportConceptRelListObj));
                            Model.QuerySupportConceptOids.AddOrUpdate(parameterOid.Value, costBearer2SupportConceptRelListObj.CostBearer2SupportConceptOid);
                        }
                    break;
                    case QueryParameterType.Team:
                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryTeamOids.Remove(parameterOid.Value);
                            break;
                        }

                        var selectedTeam = Model.AllTeamsForQueries.FirstOrDefault(team => team.TeamOid.Equals(objectOid.Value));

                        if(selectedTeam != null)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedTeam));
                            Model.QueryTeamOids.AddOrUpdate(parameterOid.Value, selectedTeam.TeamOid);
                        }
                    break;
                    case QueryParameterType.ValueListEntryType:
                        if(objectOid is null || objectOid.Value.Equals(0))
                        {
                            Model.SelectedValues.Remove(parameterOid.Value);
                            Model.QueryValueListEntryOids.Remove(parameterOid.Value);
                            
                            break;
                        }

                        var selectedValueListEntry = Model.AllValueListEntriesForQuery.FirstOrDefault(valueListEntry => valueListEntry.ValueListEntryOid?.Equals(objectOid.Value) ?? false);

                        if(selectedValueListEntry != null)
                        {
                            Model.SelectedValues.AddOrUpdate(parameterOid.Value, new SelectedValue(queryParameterType, selectedValueListEntry));
                            Model.QueryValueListEntryOids.AddOrUpdate(parameterOid.Value, selectedValueListEntry.ValueListEntryOid.Value);
                        }
                    break;
                    case QueryParameterType.Year:
                        break;
                }
            }

            return PartialView("BerichteFormPartialView", Model);
        }

        [Authorize]
        public ActionResult ExecuteQuery()
        {
            if(Model?.LoggedInEmployee?.EmployeeOid is null)
            {
                TempData[TempDataConstants.DoLogoutKey] = true;

                return PartialView("BeWoReportPartial");
            }



            var query = Model.SelectedQuery;

            var paramList = new List<QueryParamDC>();

            foreach(var item in query.Parameter)
            {
                var param = new QueryParamDC();
                paramList.Add(param);

                param.Name = item.Name;
                param.ParamType = item.ParamType;

                if(item.QueryParameterOid.HasValue && IsParameterOidInQueryValues(item.ParamType, item.QueryParameterOid.Value))
                {
                    switch(item.ParamType)
                    {
                        case QueryParameterType.Custom:
                            // Nicht implementiert
                        break;
                        case QueryParameterType.Customer:
                            var customerOid = Model.QueryCustomerOids[item.QueryParameterOid.Value];
                            var queryCustomer = Model.AllCustomersForQueries.FirstOrDefault(customer => customer.CustomerOid.Equals(customerOid));

                            param.Value = queryCustomer;
                        break;
                        case QueryParameterType.Employee:
                            var employeeOid = Model.QueryEmployeeOids[item.QueryParameterOid.Value];
                            var queryEmployee = Model.AllEmployeesForQueries.FirstOrDefault(employee => employee.EmployeeOid.Equals(employeeOid));

                            param.Value = queryEmployee;
                        break;
                        case QueryParameterType.Organisation:
                            var organisationOid = Model.QueryOrganisationOids[item.QueryParameterOid.Value];
                            var queryOrganisation = Model.AllOrganisationForQuery.FirstOrDefault(organisation => organisation.OrganisationOid.Equals(organisationOid));

                            param.Value = queryOrganisation;
                        break;
                        case QueryParameterType.Text:
                            param.Value = Model.QueryTexts[item.QueryParameterOid.Value];
                        break;
                        case QueryParameterType.Date:
                            param.Value = Model.QueryDateTimes[item.QueryParameterOid.Value];
                        break;
                        case QueryParameterType.DateRange:
                            param.Value = Model.QueryDateRanges[item.QueryParameterOid.Value];
                        break;
                        case QueryParameterType.Month:
                            param.Value = Model.QueryMonths[item.QueryParameterOid.Value];
                        break;
                        case QueryParameterType.ServiceCategory:
                            var serviceCategoryOid = Model.QueryServiceCategoryOids[item.QueryParameterOid.Value];
                            var queryServiceCategory = Model.AllServiceCategoriesForQueries.FirstOrDefault(serviceCategory => serviceCategory.ServiceCategoryOid?.Equals(serviceCategoryOid) ?? false);

                            param.Value = queryServiceCategory;
                        break;
                        case QueryParameterType.SupportConcept:
                            var cb2ScRelOid = Model.QuerySupportConceptOids[item.QueryParameterOid.Value];
                            var querySupportConcept = Model.CostBearer2SupportConceptRelListObjects.FirstOrDefault(cb2ScRel => cb2ScRel.CostBearer2SupportConceptOid.Equals(cb2ScRelOid));

                            param.Value = querySupportConcept;
                        break;
                        case QueryParameterType.Team:
                            var teamOid = Model.QueryTeamOids[item.QueryParameterOid.Value];
                            var queryTeam = Model.AllTeamsForQueries.FirstOrDefault(team => team.TeamOid.Equals(teamOid));

                            param.Value = queryTeam;
                        break;
                        case QueryParameterType.ValueListEntryType:
                            var valueListEntryOid = Model.QueryValueListEntryOids[item.QueryParameterOid.Value];
                            var queryValueListEntry = Model.AllValueListEntriesForQuery.FirstOrDefault(valueListEntry => valueListEntry.ValueListEntryOid?.Equals(valueListEntryOid) ?? false);

                            param.Value = queryValueListEntry;
                        break;
                        case QueryParameterType.Year:
                            // Nicht implementiert
                        break;
                    }
                }
                else if(item.QueryParameterOid.HasValue && item.ParamType == QueryParameterType.Month && false == IsParameterOidInQueryValues(item.ParamType, item.QueryParameterOid.Value))
                {
                    if(item.ParamType == QueryParameterType.Month)
                    {
                        var defaultDate = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
                        param.Value = defaultDate.AddMonths(-1);
                    }
                }
            }

            var dcid = $"{MobileSessionFacade.Tenant}queryeoid{Model.LoggedInEmployee.EmployeeOid.Value}";

            var queryResult = QueryService.ExecuteQuery(query.Oid, paramList);

            if(queryResult is null)
            {
                return PartialView("BeWoReportPartial", Model);
            }

            QueryService.PrepareQueryReport(queryResult, dcid);
            var queryReport = Model.ReportCreator.CreateQueryReport(query.Oid, dcid);

            Model.Report = queryReport;
            Model.ReportName = query.Title;

            return PartialView("BeWoReportPartial", Model);
        }

        [Authorize]
        private bool IsParameterOidInQueryValues(QueryParameterType parameterType, long parameterOid)
        {
            switch(parameterType)
            {
                case QueryParameterType.Custom:
                    // Nicht implementiert
                break;
                case QueryParameterType.Customer:
                    return Model.QueryCustomerOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Employee:
                    return Model.QueryEmployeeOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Organisation:
                    return Model.QueryOrganisationOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Text:
                    return Model.QueryTexts.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Date:
                    return Model.QueryDateTimes.ContainsKey(parameterOid);
                break;
                case QueryParameterType.DateRange:
                    return Model.QueryDateRanges.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Month:
                    return Model.QueryMonths.ContainsKey(parameterOid);
                break;
                case QueryParameterType.ServiceCategory:
                    return Model.QueryServiceCategoryOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.SupportConcept:
                    return Model.QuerySupportConceptOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Team:
                    return Model.QueryTeamOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.ValueListEntryType:
                    return Model.QueryValueListEntryOids.ContainsKey(parameterOid);
                break;
                case QueryParameterType.Year:
                    // Nicht implementiert
                    break;
            }

            return false;
        }

        [Authorize]
        public override string SaveCollapsibleStatus(bool isOpen, string identifier)
        {
            return SaveCollapsibleStatusToModel(Model, isOpen, identifier);
        }
    }
}