BeWoPlaner/Dakota/Models/Blocke/BlockKlient.cs

using Dakota.Models.Segmente;
using Dakota.Models.Nachrichten;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Dakota.Models.Segmente.SLLA;
using Dakota.Models.Infos;

namespace Dakota.Models.Blocke
{
    internal class BlockKlient : Block
    {

        /// <summary>
        /// Das Segment enthält die Versichertendaten eines Abrechnungsfalles (Verordnung), und gilt gleichzeitig als BeginnSegment für einen Abrechnungsfall. Jeder Abrechnungsfall ist
        /// mit einer eindeutigen Belegnummer zu kennzeichnen, die der
        /// auf der Verordnung zu übertragenen Belegnummer(s. § 4 des
        /// Richtlinientextes) entsprechen muss.
        /// </summary>
        public SegmentSLLAINV SegmentSLLAINV { get; private set; }
        /// <summary>
        /// Dieses Segment enthält bei Korrekturlieferungen die ursprünglichen Rechnungsinformationen. Es wird zunächst nur
        /// in Abhängigkeit für die Verarbeitungskennzeichen
        /// '02' Nachforderung,
        /// ‚03‘ Zuzahlungsforderung und
        /// ‚04‘ Korrekturrechnung
        /// (Schlüsselverzeichnis Anlage 3, Kapitel 8.1.7) geliefert
        /// </summary>
        public SegmentSLLAURI SegmentSLLAURI { get; private set; }
        /// <summary>
        /// Das Segment enthält den Namen und die Adressdaten des
        /// Versicherten.
        /// </summary>
        public SegmentSLLANAD SegmentSLLANAD { get; private set; }
        /// <summary>
        /// Das Segment enthält den Imagenamen bei Übermittlung von
        /// Imagearchiven durch den Absender.
        /// </summary>
        public SegmentSLLAIMG SegmentSLLAIMG { get; private set; }

        /// <summary>
        /// ENF je Abrechnungsposition
        /// SUT 0-1 je ENF
        /// TXT 0-1 je ENF
        /// MWS 0-1 je ENF
        /// </summary>
        public List<BlockAbrechnungsposition> BlockAbrechnungspositions { get; set; }

        /// <summary>
        /// Das Segment enthält Angaben über die Zuzahlung. Das Segment ist bis auf weiteres nicht zu übermitteln. Das Segment ist
        /// für spätere Ausprägungen reserviert.
        /// </summary>
        public SegmentSLLAZUZ SegmentSLLAZUZ { get; private set; }

        /// <summary>
        /// Das Segment enthält allgemeine Angaben zum Abrechnungsfall (Verordnung) und ist zu übermitteln, wenn eine ärztliche
        /// Verordnung, ein Reparatur- oder Berechtigungsschein oder
        /// Unfall/BVG vorliegt.
        /// </summary>
        public SegmentSLLAZUV SegmentSLLAZUV { get; private set; }

        public List<BlockDiagnose> BlockDiagnose { get; set; }

        /// <summary>
        /// Das Segment enthält Angaben über die von der Krankenkasse
        /// ausgesprochene Kostenzusage/Genehmigung und ist nur zu
        /// übermitteln, wenn diese vorliegt.
        /// </summary>
        public SegmentSLLASKZ SegmentSLLASKZ { get; private set; }

        /// <summary>
        /// Das Segment enthält Angaben über den abzurechnenden Gesamtbruttobetrag eines Abrechnungsfalles (Verordnung)
        /// (Summe aller ENF-Beträge ggf.zuzüglich der Mehrwertsteuer)
        /// </summary>
        public SegmentSLLABES SegmentSLLABES { get; private set; }

        public decimal GesamtbetragBrutto => SegmentSLLABES.GesamtbetragBrutto.DecimalValue;
        public decimal GesamtbetragEigenanteil => SegmentSLLABES.GesamtbetragEigenanteil.DecimalValue;
        public decimal GesamtbetragGesetzlicheZuzahlung => SegmentSLLABES.GesamtbetragGesetzlicheZuzahlung.DecimalValue;
        public decimal GesamtbetragProzentualeZuzahlung => SegmentSLLABES.GesamtbetragProzentualeZuzahlung.DecimalValue;
        public decimal PauschalerZuzahlungsbetrag => SegmentSLLABES.PauschalerZuzahlungsbetrag.DecimalValue;

        public BlockKlient()
        {
            SegmentSLLAINV = new SegmentSLLAINV();
            SegmentSLLAURI = new SegmentSLLAURI();
            SegmentSLLANAD = new SegmentSLLANAD();
            SegmentSLLAIMG = new SegmentSLLAIMG();

            BlockAbrechnungspositions = new List<BlockAbrechnungsposition>();

            // wird nicht übermittelt
            //SegmentSLLAZUZ = new SegmentSLLAZUZ();
            SegmentSLLAZUV = new SegmentSLLAZUV();

            BlockDiagnose = new List<BlockDiagnose>();

            SegmentSLLASKZ = new SegmentSLLASKZ();
            SegmentSLLABES = new SegmentSLLABES();
        }

        public override List<Segment> GetAllSegments()
        {
            var res = new List<Segment>();

            res.Add(SegmentSLLAINV);
            // res.Add(SegmentSLLAURI);
            res.Add(SegmentSLLANAD);

            foreach (var block in BlockAbrechnungspositions)
            {
                res.AddRange(block.GetSegments());
            }

            res.Add(SegmentSLLAZUV);

            foreach (var block in BlockDiagnose)
            {
                res.AddRange(block.GetSegments());
            }

            res.Add(SegmentSLLASKZ);
            res.Add(SegmentSLLABES);

            return res;
        }
        public override int GetUNHCount() => 0;

        public void Apply(InfoAbrechnungsfall info)
        {
            SegmentSLLAINV.VersichertenNummer.SetValue(info.VersichtertenNummer);
            SegmentSLLAINV.Versichertenstatus.SetValue(info.Versichertenstatus);
            SegmentSLLAINV.Beleginformation.SetValue(info.Beleginformation);
            SegmentSLLAINV.Belegnummer.SetValue(info.Belegnummer);
            // block.SegmentSLLAINV.KennzeichenBesondereVersorgungsform.SetValue(invoiceInfo.Kenn)

            SegmentSLLANAD.Vorname.SetValue(info.VersichtertenVorname);
            SegmentSLLANAD.Nachname.SetValue(info.VersichtertenNachname);
            SegmentSLLANAD.Geburtsdatum.SetValue(info.VersichtertenGeburtstag);
            SegmentSLLANAD.StraßeNr.SetValue(info.VersichtertenStraßeNr);
            SegmentSLLANAD.PLZ.SetValue(info.VersichtertenPLZ);
            SegmentSLLANAD.Wohnort.SetValue(info.VersichtertenWohnort);
            SegmentSLLANAD.Länderkennzeichen.SetValue(info.VersichtertenLanderkennung);

            foreach (var posinfo in info.InfosAbrechnungsposition.OrderBy(x => x.DatumDerLeistungserbringung))
            {
                var block = new BlockAbrechnungsposition();

                block.Apply(posinfo);

                BlockAbrechnungspositions.Add(block);
            }

            SegmentSLLAZUV.Betriebsstättennummer.SetValue(info.Betriebsstättennummer);
            SegmentSLLAZUV.LebenslangeArztnummer.SetValue(info.LebenslangeArztnummer);
            SegmentSLLAZUV.VerordnungsAusstellEinsatzdatum.SetValue(info.Verordnungsdatum);
            SegmentSLLAZUV.Zuzahlungskennzeichen.SetValue(info.Zuzahlungskennzeichen);
            SegmentSLLAZUV.Unfallkennzeichen.SetValue(info.Unfallkennzeichen);
            SegmentSLLAZUV.KennzeichenBVGSonstiges.SetValue(info.KennzeichenBVGSonstiges);
            SegmentSLLAZUV.KennzeichenVerordnungsbesonderheiten.SetValue(info.KennzeichenVerordnungsbesonderheiten);

            if (info.DakotaInfoDiagnosen is object && info.DakotaInfoDiagnosen.Any())
            {
                foreach (var diagnose in info.DakotaInfoDiagnosen)
                {
                    var block = new BlockDiagnose();

                    block.Apply(diagnose);

                    BlockDiagnose.Add(block);
                }
            }

            SegmentSLLASKZ.Genehmigungskennzeichen.SetValue(info.Genehmigungskennzeichen);
            SegmentSLLASKZ.DatumGenehmigung.SetValue(info.DatumDerGenehmigung);
            SegmentSLLASKZ.ArtGenehmigung.SetValue(info.ArtDerGenehmigung);

            CalculateSums();
        }

        private void CalculateSums()
        {
            var gesamtbrutto = BlockAbrechnungspositions.Sum(pos => Math.Round(pos.AnzahlEinheit * pos.EinzelbetragAbrechnungsposition, 2, MidpointRounding.AwayFromZero));
            var gesamtproz = BlockAbrechnungspositions.Sum(pos => Math.Round(pos.AnzahlEinheit * pos.BetragZuzahlung, 2, MidpointRounding.AwayFromZero));
            var diff = gesamtbrutto - gesamtproz;
            var pauschaler = Math.Min(10, diff);
            var gesamtgesetz = gesamtproz + pauschaler;

            SegmentSLLABES.GesamtbetragBrutto.SetValue(gesamtbrutto);
            // SegmentSLLABES.GesamtbetragGesetzlicheZuzahlung.SetValue(gesamtgesetz);
            // SegmentSLLABES.GesamtbetragProzentualeZuzahlung.SetValue(gesamtproz);
            // SegmentSLLABES.PauschalerZuzahlungsbetrag.SetValue(pauschaler);
            // SegmentSLLABES.GesamtbetragEigenanteil.SetValue(0);
        }
    }
}