using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using BeWo.Report;
using BeWo.Report.ReportObjects;
using BeWoPlanerMobil.Models;
using BeWoPlanerMobil.Service;
using BeWoPlanerMobil.Util;
using BeWoPlanerMobil.Util.ReportUtils;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;

namespace BeWoPlanerMobil.Controllers
{
    /*
     * Quittierungsbeleg wie im Fat-Client implementieren ✓
     * Mit Unterschriftenfunktion für den Mitarbeiter ✓
     * Liste mit allen ServiceRecords des Mitarbeiters für einen Klienten ✓
     *
     * TODO: Beim Speichern von ServiceRecords prüfen, ob es schon eine Mitarbeiterunterschrift für Quittierungsbelege gibt ✓
     * TODO: Unterschrift in Quittierungsbeleg einbauen
     * TODO: Bei neuer Unterschrift für einen Zeitraum die alte löschen
     
     * TODO: 
     * TODO: Flag wie ShowSignature, genannt ShowEmployeeSignature
     * TODO: ServiceRecords eines Quittierungsbelegs müssen mit einer Mitarbeiterunterschrift verknüpft sein, damit die Unterschrift angezeigt wird.
     * TODO: 
     * TODO: Rechte: 
     * TODO: 
     * TODO: 
     *
     *
     */

    public class ReportController : AbstractBaseController
    {
        private ReportModel _Model;

        public ReportModel Model
        {
            get
            {
                if(!MobileSessionFacade.IsUserLoggedIn())
                {
                    RedirectToActionPermanent("Index", "Login");
                    return null;
                }

                if(((ReportModel) Session[ModelSessionConstants.ReportModelKey])?.Employee == null)
                {
                    _Model = new ReportModel {Employee = MobileSessionFacade.LoggedInEmployee};
                    Session[ModelSessionConstants.ReportModelKey] = _Model;
                }
                else
                {
                    _Model = (ReportModel) Session[ModelSessionConstants.ReportModelKey];
                }

                return _Model;
            }
        }

        [Authorize]
        public ActionResult Report()
        {
            if(!MobileSessionFacade.IsUserLoggedIn() || Request.Browser.Browser.Equals("InternetExplorer") || !AbstractModel.IsAllowedToSeeScheduler)
            {
                return Logout();
            }

            if(!AbstractModel.IsAllowedToSeeBills)
            {
                return RedirectToActionPermanent("Main", "Main");
            }

            var filterEnums = Enum.GetValues(typeof(QBFilterEnum)).Cast<QBFilterEnum>();

            Model.QbFilters.Clear();
            foreach(var filterEnum in filterEnums)
            {
                Model.QbFilters.AddIfNotIn(new QbFilterItem(filterEnum));
            }

            Model.Customers = EmployeeService.GetActiveCompactCustomersForEmployee(null).OrderBy(d => d.ToString()).ToList();

            Model.Employees = EmployeeService.GetActiveCompactEmployeesForEmployee(MobileSessionFacade.LoggedInCompactEmployee.EmployeeOid);

            Model.ServiceCategories = OperationsService.GetAllServiceCategories();

            Model.Organisations = CustomerService.GetAllCostBearerCompact();
            Model.Organisations.Sort((x, y) => x.Name.CompareTo(y.Name));

            Model.AllTeams = EmployeeService.GetAllActiveCompactTeamsForEmployee(MobileSessionFacade.LoggedInEmployee.EmployeeOid);

            return View(Model);
        }

        [Authorize]
        [HttpPost]
        public ActionResult CreateServiceOverview(FormCollection formCollection)
        {
            if(Model?.Employee?.EmployeeOid == null)
            {
                return Logout();
            }

            if(Model.SelectedFilterItem.FilterEnum == QBFilterEnum.KlientenAuswahl)
            {
                var customerOidString = formCollection[FormCollectionConstants.SelectedCustomerOidKey];

                var isCustomerOidSuccessful = long.TryParse(customerOidString, out var selectedCustomerOid);

                if(isCustomerOidSuccessful)
                {
                    var selectedCustomer = Model.Customers.FirstOrDefault(customer => customer.CustomerOid == selectedCustomerOid);

                    Model.SelectedCustomer = selectedCustomer;
                }
            }
            else
            {
                Model.SelectedCustomer = null;
            }

            if(Model.SelectedFilterItem.FilterEnum == QBFilterEnum.TeamAuswahl)
            {
                var teamOidString = formCollection[FormCollectionConstants.SelectedTeamOidKey];

                var isTeamOidSuccessful = long.TryParse(teamOidString, out var selectedTeamOid);

                if(isTeamOidSuccessful)
                {
                    var selectedTeam = Model.AllTeams.FirstOrDefault(team => team.TeamOid == selectedTeamOid);

                    Model.SelectedTeam = selectedTeam;
                }
            }
            else
            {
                Model.SelectedTeam = null;
            }

            var startDay = Model.SelectedStartDay;
            var endDay   = Model.SelectedEndDay;

            var reportObjects = new List<ServicesOverviewRO>();

            var month = Model.SelectedMonth;
            var year = Model.SelectedYear;

            var organisationOid = Model.SelectedOrganisationOid ?? 0;
            var employeeOid = Model.SelectedEmployeeOid ?? 0;
            var serviceCategoryOid = Model.SelectedServiceCategoryOid;
            var teamOid = Model.SelectedTeamOid;
            var customerOid = Model.SelectedCustomerOid ?? 0;

            switch(Model.SelectedFilterItem.FilterEnum)
            {
                case QBFilterEnum.AlleKlienten:
                    reportObjects = ServicesOverviewRO.Create(month, year, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid);
                    break;
                case QBFilterEnum.NurKlientenMeinesTeams:
                    var teamRelatedCustomerOids = GetTeamCustomerOids();
                    reportObjects.AddRange(teamRelatedCustomerOids.Select(cOid => ServicesOverviewRO.Create(cOid, month, year, true, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)));
                    break;
                case QBFilterEnum.MeineKlienten:
                    var myRelatedCustomerOids = DefaultReportCreator.GetMeineKlientenOids();
                    reportObjects.AddRange(myRelatedCustomerOids.Select(cOid => ServicesOverviewRO.Create(cOid, month, year, true, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)));
                    break;
                case QBFilterEnum.KlientenAuswahl:
                    reportObjects = new List<ServicesOverviewRO> { ServicesOverviewRO.Create(customerOid, month, year, false, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)};
                    break;
                case QBFilterEnum.TeamAuswahl:
                    var customerOids = GetTeamCustomerOids(teamOid);
                    reportObjects.AddRange(customerOids.Select(cOid => ServicesOverviewRO.Create(cOid, month, year, true, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid)));
                    break;
                default:
                    reportObjects = ServicesOverviewRO.Create(month, year, organisationOid, employeeOid, startDay, endDay, serviceCategoryOid, true, false);
                    break;
            }

            Model.ConfirmationReceiptObject = null;
            Model.ConfirmationReceiptObject = new ConfirmationReceiptObject(BuildInformationString(), new List<QuittierungsbelegResult>());

            reportObjects.DoForEach(ro =>
            {
                var quittierungsbelegItems = new List<QuittierungsbelegItem>();

                ro.Services.DoForEach(serviceDetail => { quittierungsbelegItems.Add(new QuittierungsbelegItem(serviceDetail)); });

                Model.ConfirmationReceiptObject.ConfirmationReceiptResultList.Add(new QuittierungsbelegResult(ro.CustomerName, quittierungsbelegItems));
            });

            if(Model.ConfirmationReceiptObject.ConfirmationReceiptResultList.Count == 0)
            {
                TempData["HasWarningMessage"] = true;
            }

            return RedirectToActionPermanent("Report");
        }

        private string BuildInformationString()
        {
            var stringBuilder = new StringBuilder("Einträge für ");

            //Einträge für [alle Klienten/die Klienten meines Teams/meine Klienten/[CustomerName]/[TeamName]] [von [Mitarbeiter] [bei [Kostenträger]] und [Leistungskategorie]] vom 01.10. bis 31.10.2020
            // Einträge für Grube, Clair von Fisher, George bei LWL und face-to-face vom 01.10. bis 31.10.2020
            switch(Model.SelectedFilterItem.FilterEnum)
            {
                case QBFilterEnum.KlientenAuswahl:
                    stringBuilder.Append(Model.SelectedCustomer);
                    break;
                case QBFilterEnum.MeineKlienten:
                    stringBuilder.Append("meine Klienten");
                    break;
                case QBFilterEnum.NurKlientenMeinesTeams:
                    stringBuilder.Append("die Klienten meines Teams");
                    break;
                case QBFilterEnum.TeamAuswahl:
                    stringBuilder.Append(Model.SelectedTeam);
                    break;
                default:
                    stringBuilder.Append("alle Klienten");
                    break;
            }

            stringBuilder.Append(" ");

            if(Model.SelectedEmployee != null)
            {
                stringBuilder.Append($"von {Model.SelectedEmployee} ");
            }

            if(Model.SelectedOrganisation != null)
            {
                stringBuilder.Append($"bei {Model.SelectedOrganisation} ");
            }

            if(Model.SelectedServiceCategory != null)
            {
                if(Model.SelectedEmployee != null || Model.SelectedOrganisation != null)
                {
                    stringBuilder.Append("und ");
                }

                stringBuilder.Append(Model.SelectedServiceCategory.Name);
            }

            var month = Model.SelectedMonth;
            var year = Model.SelectedYear;
            var vom = Model.SelectedStartDay;
            var bis = Model.SelectedEndDay;

            stringBuilder.Append($"vom {vom}.{month}. bis {bis}.{month}.{year}");

            return stringBuilder.ToString();
        }

        private IEnumerable<long> GetTeamCustomerOids(long? teamOid = null)
        {
            var customerOids = new List<long>();

            if(MobileSessionFacade.LoggedInEmployee?.EmployeeOid != null)
            {
                customerOids.AddRangeIfElementsNotIn(EmployeeService.GetTeamRelatedCustomerOids(MobileSessionFacade.LoggedInEmployee.EmployeeOid.Value, teamOid));
            }

            return customerOids;
        }

        [Authorize]
        public string SetCustomer(long customerOid)
        {
            if(Model == null)
            {
                return _LeerzeichenFuerGetMethoden;
            }

            Model.SelectedCustomer = Model.Customers.FirstOrDefault(customer => customer.CustomerOid == customerOid);

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        [HttpPost]
        public string CreateEmployeeSignatureForServiceOverview(string base64SignatureString)
        {
            if(Model == null)
            {
                Logout();
            }

            var confirmationReceiptSignature = new ConfirmationReceiptSignatureDC();

            var serviceRecordOids = new List<long>();

            Model.ConfirmationReceiptObject.ConfirmationReceiptResultList.DoForEach(result => result.Items.DoForEach(item => serviceRecordOids.AddIfNotIn(item.ServiceRecordOid)));

            var serviceRecords = OperationsService.GetServiceRecordsByIds(serviceRecordOids);

            confirmationReceiptSignature.ServiceRecords = serviceRecords;
            confirmationReceiptSignature.EmployeeOid = Model.Employee.EmployeeOid;

            // TODO: Prüfen, ob es bereits eine oder mehrere Mitarbeiterunterschriften gibt und die gegebenenfalls löschen
            var signatureToDelete = OperationsService.FindConfirmationReceiptSignaturesByEmployeeAndServiceRecords(Model.Employee.EmployeeOid.Value, serviceRecordOids);

            using(var signatureBitmap = SignatureUtils.Base64StringToBitmap(base64SignatureString.Split(',')[1]))
            {
                var isValid = SignatureUtils.ValidateSignature(signatureBitmap);

                if(!isValid)
                {
                    return MobileUtils.SerializeObject("Das Unterschriftenfeld darf nicht leer sein.");
                }

                confirmationReceiptSignature.SignatureImage = base64SignatureString;

                OperationsService.InsertConfirmationReceiptSignature(confirmationReceiptSignature);
            }

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string ValidateEmployeeSignature()
        {
            if(Model?.Employee?.EmployeeOid == null)
            {
                Logout();
                return _LeerzeichenFuerGetMethoden;
            }

            var serviceRecordOids = new List<long>();

            Model.ConfirmationReceiptObject.ConfirmationReceiptResultList.DoForEach(result =>
            {
                result.Items.DoForEach(item =>
                {
                    serviceRecordOids.AddIfNotIn(item.ServiceRecordOid);
                });
            });

            var hasSignature = OperationsService.HasConfirmationReceiptSignaturesByEmployeeAndServiceRecords(Model.Employee.EmployeeOid.Value, serviceRecordOids);

            return hasSignature.ToString();
        }

        [Authorize]
        public string CheckForEmployeeSignature(string customerOidString, string monthString, string yearString, string startDayString, string endDayString)
        {
            if(Model?.Employee?.EmployeeOid == null)
            {
                Logout();
            }

            var isParsingSuccessful1 = long.TryParse(customerOidString, out var customerOid);
            var isParsingSuccessful2 = int.TryParse(monthString, out var month);
            var isParsingSuccessful3 = int.TryParse(yearString, out var year);
            var isParsingSuccessful4 = int.TryParse(startDayString, out var startDay);
            var isParsingSuccessful5 = int.TryParse(endDayString, out var endDay);

            if(isParsingSuccessful1 && isParsingSuccessful2 && isParsingSuccessful3 && isParsingSuccessful4 && isParsingSuccessful5 && year > 0)
            {
                var hasSignature = OperationsService.HasConfirmationReceiptSignatureByDateAndCustomer(customerOid, new DateTimeSpan(new DateTime(year, month, startDay), new DateTime(year, month, endDay)));

                return MobileUtils.SerializeObject(hasSignature);
            }

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string ChangeDateSelection(string startDayString, string endDayString, string monthString, string yearString)
        {
            if(Model == null)
            {
                Logout();
            }

            var isParsingSuccessful1 = int.TryParse(startDayString, out var startDay);
            var isParsingSuccessful2 = int.TryParse(endDayString, out var endDay);
            var isParsingSuccessful3 = int.TryParse(monthString, out var month);
            var isParsingSuccessful4 = int.TryParse(yearString, out var year);

            if(isParsingSuccessful1 && isParsingSuccessful2 && isParsingSuccessful3 && isParsingSuccessful4)
            {
                var start = new DateTime(year, month, startDay);
                var end = new DateTime(year, month, endDay);

                Model.SelectedEndDay   = end.Day;
                Model.SelectedStartDay = start.Day;
                Model.SelectedMonth    = month;
                Model.SelectedYear     = year;

                return MobileUtils.SerializeObject(true);
            }

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string ChangeFilters(string employeeOidStr, string organisationOidStr, string categoryOidStr)
        {
            if(Model == null)
            {
                Logout();
            }

            var isParsingSuccessful1 = long.TryParse(employeeOidStr, out var employeeOid);
            var isParsingSuccessful2 = long.TryParse(organisationOidStr, out var organisationOid);
            var isParsingSuccessful3 = long.TryParse(categoryOidStr, out var categoryOid);

            Model.SelectedEmployee = isParsingSuccessful1 ? EmployeeService.LoadCompactEmployee(employeeOid) : null;

            Model.SelectedOrganisation = isParsingSuccessful2 ? CustomerService.LoadOrganisationCompact(organisationOid) : null;

            Model.SelectedServiceCategory = isParsingSuccessful3 ? OperationsService.LoadServiceCategory(categoryOid) : null;

            return _LeerzeichenFuerGetMethoden;
        }

        [Authorize]
        public string SetQbFilterEnum(string filterEnumString)
        {
            if(Model == null)
            {
                Logout();
                return _LeerzeichenFuerGetMethoden;
            }

            var isParsingSuccessful = int.TryParse(filterEnumString, out var filterEnumValue);

            if(isParsingSuccessful)
            {
                var selectedFilterEnum = (QBFilterEnum) filterEnumValue;

                Model.SelectedFilterItem = new QbFilterItem(selectedFilterEnum);
            }

            return _LeerzeichenFuerGetMethoden;
        }
    }
}