import { generateUniformFormatReport } from '../../../../../shaam-uniform-format-generator/src/index.js';
import { dateToTimelessDateString, formatFinancialAmount, formatFinancialIntAmount, optionalDateToTimelessDateString, } from '../../../shared/helpers/index.js';
import { AdminContextProvider } from '../../admin-context/providers/admin-context.provider.js';
import { BusinessesProvider } from '../../financial-entities/providers/businesses.provider.js';
import { FinancialEntitiesProvider } from '../../financial-entities/providers/financial-entities.provider.js';
import { getEntryTypeByRecord } from '../helpers/pcn.helper.js';
import { accountsForUniformFormat, businessForUniformFormat, journalEntriesForUniformFormat, } from '../helpers/uniform-format.helper.js';
import { getVatRecords } from './get-vat-records.resolver.js';
import { corporateTaxRulingComplianceReport, corporateTaxRulingComplianceReportDifferences, } from './reports/corporate-tax-ruling-compliance-report.js';
import { profitAndLossReport, profitAndLossReportYearMapper, reportCommentaryRecordMapper, reportCommentarySubRecordMapper, } from './reports/profit-and-loss-report.resolver.js';
import { taxReport, taxReportYearMapper } from './reports/tax-report.js';
import { yearlyLedgerReport } from './reports/yearly-ledger-report.resolver.js';
export const reportsResolvers = {
    Query: {
        vatReport: (_, args, { injector }) => getVatRecords(args, injector),
        profitAndLossReport,
        taxReport,
        corporateTaxRulingComplianceReport,
        yearlyLedgerReport,
        uniformFormat: async (_, { fromDate, toDate }, context, info) => {
            const { injector } = context;
            const accountsPromise = accountsForUniformFormat(context, info, fromDate, toDate).catch(err => {
                const message = `Failed to fetch accounts for uniform format: ${err.message}`;
                console.error(`${message}: ${err}`);
                throw new Error(message);
            });
            const businessPromise = businessForUniformFormat(injector, fromDate, toDate).catch(err => {
                const message = `Failed to fetch main business info for uniform format: ${err.message}`;
                console.error(`${message}: ${err}`);
                throw new Error(message);
            });
            const journalEntriesPromise = journalEntriesForUniformFormat(injector, fromDate, toDate).catch(err => {
                const message = `Failed to fetch journal entries for uniform format: ${err.message}`;
                console.error(`${message}: ${err}`);
                throw new Error(message);
            });
            const [accounts, business, journalEntries] = await Promise.all([
                accountsPromise,
                businessPromise,
                journalEntriesPromise,
            ]);
            // generate files
            const report = generateUniformFormatReport({
                journalEntries,
                accounts,
                business,
                documents: [],
                inventory: [],
            }, { fileNameBase: '', validationMode: 'collect-all' });
            if (report.summary.errors && report.summary.errors.length > 0) {
                throw new Error(`Uniform format report generation failed with validation errors: ${report.summary.errors
                    .map(err => `${err.recordType}[${err.recordIndex}].${err.field}: ${err.message}`)
                    .join(', ')}`);
            }
            // return files as a response
            return {
                ini: report.iniText,
                bkmvdata: report.dataText,
            };
        },
    },
    VatReportRecord: {
        allocationNumber: raw => raw.allocationNumber ?? null,
        documentId: raw => raw.documentId,
        chargeAccountantStatus: raw => raw.chargeAccountantStatus,
        chargeId: raw => raw.chargeId,
        amount: raw => formatFinancialAmount(raw.documentAmount, raw.currencyCode),
        business: (raw, _, { injector }) => raw.businessId
            ? injector
                .get(FinancialEntitiesProvider)
                .getFinancialEntityByIdLoader.load(raw.businessId)
                .then(res => res ?? null)
            : null,
        chargeDate: raw => dateToTimelessDateString(raw.chargeDate),
        documentDate: raw => optionalDateToTimelessDateString(raw.documentDate),
        documentSerial: raw => raw.documentSerial,
        image: raw => raw.documentUrl,
        localAmount: async (raw, _, { injector }) => {
            const { defaultLocalCurrency } = await injector
                .get(AdminContextProvider)
                .getVerifiedAdminContext();
            return raw.eventLocalAmount
                ? formatFinancialAmount(raw.eventLocalAmount, defaultLocalCurrency)
                : null;
        },
        localVatAfterDeduction: async (raw, _, { injector }) => {
            const { defaultLocalCurrency } = await injector
                .get(AdminContextProvider)
                .getVerifiedAdminContext();
            return raw.localVatAfterDeduction
                ? formatFinancialAmount(raw.localVatAfterDeduction, defaultLocalCurrency)
                : null;
        },
        roundedLocalVatAfterDeduction: async (raw, _, { injector }) => {
            const { defaultLocalCurrency } = await injector
                .get(AdminContextProvider)
                .getVerifiedAdminContext();
            return raw.roundedVATToAdd
                ? formatFinancialIntAmount(raw.roundedVATToAdd, defaultLocalCurrency)
                : null;
        },
        taxReducedLocalAmount: async (raw, _, { injector }) => {
            const { defaultLocalCurrency } = await injector
                .get(AdminContextProvider)
                .getVerifiedAdminContext();
            return raw.localAmountBeforeVAT
                ? formatFinancialIntAmount(raw.localAmountBeforeVAT, defaultLocalCurrency)
                : null;
        },
        taxReducedForeignAmount: raw => raw.foreignAmountBeforeVAT
            ? formatFinancialIntAmount(raw.foreignAmountBeforeVAT, raw.currencyCode)
            : null,
        localVat: async (raw, _, { injector }) => {
            const { defaultLocalCurrency } = await injector
                .get(AdminContextProvider)
                .getVerifiedAdminContext();
            return raw.localVat ? formatFinancialAmount(raw.localVat, defaultLocalCurrency) : null;
        },
        foreignVat: raw => raw.foreignVat ? formatFinancialAmount(raw.foreignVat, raw.currencyCode) : null,
        foreignVatAfterDeduction: raw => raw.foreignVatAfterDeduction
            ? formatFinancialAmount(raw.foreignVatAfterDeduction, raw.currencyCode)
            : null,
        vatNumber: (raw, _, { injector }) => raw.businessId
            ? injector
                .get(BusinessesProvider)
                .getBusinessByIdLoader.load(raw.businessId)
                .then(entity => entity?.vat_number ?? null)
            : null,
        recordType: raw => getEntryTypeByRecord(raw),
        isProperty: raw => raw.isProperty,
    },
    CorporateTaxRulingComplianceReport: {
        id: report => report.id,
        year: report => report.year,
        totalIncome: report => report.totalIncome,
        businessTripRndExpenses: report => report.businessTripRndExpenses,
        foreignDevelopmentExpenses: report => report.foreignDevelopmentExpenses,
        foreignDevelopmentRelativeToRnd: report => report.foreignDevelopmentRelativeToRnd,
        localDevelopmentExpenses: report => report.localDevelopmentExpenses,
        localDevelopmentRelativeToRnd: report => report.localDevelopmentRelativeToRnd,
        researchAndDevelopmentExpenses: report => report.researchAndDevelopmentExpenses,
        rndRelativeToIncome: report => report.rndRelativeToIncome,
        differences: corporateTaxRulingComplianceReportDifferences,
    },
    ProfitAndLossReportYear: profitAndLossReportYearMapper,
    TaxReportYear: taxReportYearMapper,
    ReportCommentaryRecord: reportCommentaryRecordMapper,
    ReportCommentarySubRecord: reportCommentarySubRecordMapper,
};
//# sourceMappingURL=reports.resolver.js.map