ezbookkeeping/src/core/explorer.ts

import { type NameValue } from '@/core/base.ts';
import { DateRange } from '@/core/datetime.ts';

export enum TransactionExplorerConditionRelation {
    First = 'first',
    And = 'and',
    Or = 'or',
    AndSub = 'and(',
    OrSub = 'or(',
    SubEnd = ')'
}

export type TransactionExplorerSubConditionStartRelation = '(';
export const TransactionExplorerSubConditionStartRelationPlaceholder: TransactionExplorerSubConditionStartRelation = '(';

export const TransactionExplorerConditionRelationPriority: Record<TransactionExplorerConditionRelation, number> = {
    [TransactionExplorerConditionRelation.First]: 0,
    [TransactionExplorerConditionRelation.Or]: 1,
    [TransactionExplorerConditionRelation.And]: 2,
    [TransactionExplorerConditionRelation.AndSub]: 0,
    [TransactionExplorerConditionRelation.OrSub]: 0,
    [TransactionExplorerConditionRelation.SubEnd]: 0
};


export enum TransactionExplorerConditionFieldType {
    Undefined = 'undefined',
    TransactionTimeDayOfWeek = 'transactionTimeDayOfWeek',
    TransactionTimeDayOfMonth = 'transactionTimeDayOfMonth',
    TransactionTimeMonthOfYear = 'transactionTimeMonthOfYear',
    TransactionTimeHourOfDay = 'transactionTimeHourOfDay',
    TransactionTimezone = 'transactionTimezone',
    TransactionType = 'transactionType',
    TransactionCategory = 'transactionCategory',
    SourceAccount = 'sourceAccount',
    DestinationAccount = 'destinationAccount',
    SourceAmount = 'sourceAmount',
    DestinationAmount = 'destinationAmount',
    GeoLocation = 'geoLocation',
    TransactionTag = 'transactionTag',
    Pictures = 'pictures',
    Description = 'description'
}

export class TransactionExplorerConditionField implements NameValue {
    private static readonly allInstances: TransactionExplorerConditionField[] = [];
    private static readonly allInstancesByValue: Record<string, TransactionExplorerConditionField> = {};

    public static readonly TransactionTimeDayOfWeek = new TransactionExplorerConditionField('Transaction Day of Week', TransactionExplorerConditionFieldType.TransactionTimeDayOfWeek);
    public static readonly TransactionTimeDayOfMonth = new TransactionExplorerConditionField('Transaction Day of Month', TransactionExplorerConditionFieldType.TransactionTimeDayOfMonth)
    public static readonly TransactionTimeMonthOfYear = new TransactionExplorerConditionField('Transaction Month of Year', TransactionExplorerConditionFieldType.TransactionTimeMonthOfYear);
    public static readonly TransactionTimeHourOfDay = new TransactionExplorerConditionField('Transaction Hour of Day', TransactionExplorerConditionFieldType.TransactionTimeHourOfDay);
    public static readonly TransactionTimezone = new TransactionExplorerConditionField('Transaction Timezone', TransactionExplorerConditionFieldType.TransactionTimezone);
    public static readonly TransactionType = new TransactionExplorerConditionField('Transaction Type', TransactionExplorerConditionFieldType.TransactionType);
    public static readonly TransactionCategory = new TransactionExplorerConditionField('Category', TransactionExplorerConditionFieldType.TransactionCategory);
    public static readonly SourceAccount = new TransactionExplorerConditionField('Source Account', TransactionExplorerConditionFieldType.SourceAccount);
    public static readonly DestinationAccount = new TransactionExplorerConditionField('Destination Account', TransactionExplorerConditionFieldType.DestinationAccount);
    public static readonly SourceAmount = new TransactionExplorerConditionField('Amount', TransactionExplorerConditionFieldType.SourceAmount);
    public static readonly DestinationAmount = new TransactionExplorerConditionField('Transfer In Amount', TransactionExplorerConditionFieldType.DestinationAmount);
    public static readonly GeoLocation = new TransactionExplorerConditionField('Geographic Location', TransactionExplorerConditionFieldType.GeoLocation);
    public static readonly TransactionTag = new TransactionExplorerConditionField('Tags', TransactionExplorerConditionFieldType.TransactionTag);
    public static readonly Pictures = new TransactionExplorerConditionField('Pictures', TransactionExplorerConditionFieldType.Pictures);
    public static readonly Description = new TransactionExplorerConditionField('Description', TransactionExplorerConditionFieldType.Description);

    public readonly name: string;
    public readonly value: TransactionExplorerConditionFieldType;

    private constructor(name: string, value: TransactionExplorerConditionFieldType) {
        this.name = name;
        this.value = value;

        TransactionExplorerConditionField.allInstances.push(this);
        TransactionExplorerConditionField.allInstancesByValue[value] = this;
    }

    public static values(): TransactionExplorerConditionField[] {
        return TransactionExplorerConditionField.allInstances;
    }

    public static valueOf(value: string): TransactionExplorerConditionField | undefined {
        return TransactionExplorerConditionField.allInstancesByValue[value];
    }
}

export enum TransactionExplorerConditionOperatorType {
    In = 'in',
    NotIn = 'notIn',
    GreaterThan = 'greaterThan',
    LessThan = 'lessThan',
    Equals = 'equals',
    NotEquals = 'notEquals',
    Between = 'between',
    NotBetween = 'notBetween',
    HasAny = 'hasAny',
    HasAll = 'hasAll',
    NotHasAny = 'notHasAny',
    NotHasAll = 'notHasAll',
    IsEmpty = 'isEmpty',
    IsNotEmpty = 'isNotEmpty',
    Contains = 'contains',
    NotContains = 'notContains',
    StartsWith = 'startsWith',
    NotStartsWith = 'notStartsWith',
    EndsWith = 'endsWith',
    NotEndsWith = 'notEndsWith',
    RegexMatch = 'regexMatch',
    NotRegexMatch = 'notRegexMatch',
    MinuteOffsetBetween = 'minuteOffsetBetween',
    MinuteOffsetNotBetween = 'minuteOffsetNotBetween',
    LatitudeBetween = 'latitudeBetween',
    LatitudeNotBetween = 'latitudeNotBetween',
    LongitudeBetween = 'longitudeBetween',
    LongitudeNotBetween = 'longitudeNotBetween'
}

export class TransactionExplorerConditionOperator implements NameValue {
    private static readonly allInstances: TransactionExplorerConditionOperator[] = [];
    private static readonly allInstancesByValue: Record<string, TransactionExplorerConditionOperator> = {};

    public static readonly In = new TransactionExplorerConditionOperator('In', TransactionExplorerConditionOperatorType.In);
    public static readonly NotIn = new TransactionExplorerConditionOperator('Not in', TransactionExplorerConditionOperatorType.NotIn);
    public static readonly GreaterThan = new TransactionExplorerConditionOperator('Greater than', TransactionExplorerConditionOperatorType.GreaterThan);
    public static readonly LessThan = new TransactionExplorerConditionOperator('Less than', TransactionExplorerConditionOperatorType.LessThan);
    public static readonly Equals = new TransactionExplorerConditionOperator('Equal to', TransactionExplorerConditionOperatorType.Equals);
    public static readonly NotEquals = new TransactionExplorerConditionOperator('Not equal to', TransactionExplorerConditionOperatorType.NotEquals);
    public static readonly Between = new TransactionExplorerConditionOperator('Between', TransactionExplorerConditionOperatorType.Between);
    public static readonly NotBetween = new TransactionExplorerConditionOperator('Not between', TransactionExplorerConditionOperatorType.NotBetween);
    public static readonly HasAny = new TransactionExplorerConditionOperator('Has any', TransactionExplorerConditionOperatorType.HasAny);
    public static readonly HasAll = new TransactionExplorerConditionOperator('Has all', TransactionExplorerConditionOperatorType.HasAll);
    public static readonly NotHasAny = new TransactionExplorerConditionOperator('Does not have any', TransactionExplorerConditionOperatorType.NotHasAny);
    public static readonly NotHasAll = new TransactionExplorerConditionOperator('Does not have all', TransactionExplorerConditionOperatorType.NotHasAll);
    public static readonly IsEmpty = new TransactionExplorerConditionOperator('Is empty', TransactionExplorerConditionOperatorType.IsEmpty);
    public static readonly IsNotEmpty = new TransactionExplorerConditionOperator('Is not empty', TransactionExplorerConditionOperatorType.IsNotEmpty);
    public static readonly Contains = new TransactionExplorerConditionOperator('Contains', TransactionExplorerConditionOperatorType.Contains);
    public static readonly NotContains = new TransactionExplorerConditionOperator('Does not contain', TransactionExplorerConditionOperatorType.NotContains);
    public static readonly StartsWith = new TransactionExplorerConditionOperator('Starts with', TransactionExplorerConditionOperatorType.StartsWith);
    public static readonly NotStartsWith = new TransactionExplorerConditionOperator('Does not start with', TransactionExplorerConditionOperatorType.NotStartsWith);
    public static readonly EndsWith = new TransactionExplorerConditionOperator('Ends with', TransactionExplorerConditionOperatorType.EndsWith);
    public static readonly NotEndsWith = new TransactionExplorerConditionOperator('Does not end with', TransactionExplorerConditionOperatorType.NotEndsWith);
    public static readonly RegexMatch = new TransactionExplorerConditionOperator('Matches regex', TransactionExplorerConditionOperatorType.RegexMatch);
    public static readonly NotRegexMatch = new TransactionExplorerConditionOperator('Does not match regex', TransactionExplorerConditionOperatorType.NotRegexMatch);
    public static readonly MinuteOffsetBetween = new TransactionExplorerConditionOperator('Minute offset is between', TransactionExplorerConditionOperatorType.MinuteOffsetBetween);
    public static readonly MinuteOffsetNotBetween = new TransactionExplorerConditionOperator('Minute offset is not between', TransactionExplorerConditionOperatorType.MinuteOffsetNotBetween);
    public static readonly LatitudeBetween = new TransactionExplorerConditionOperator('Latitude is between', TransactionExplorerConditionOperatorType.LatitudeBetween);
    public static readonly LatitudeNotBetween = new TransactionExplorerConditionOperator('Latitude is not between', TransactionExplorerConditionOperatorType.LatitudeNotBetween);
    public static readonly LongitudeBetween = new TransactionExplorerConditionOperator('Longitude is between', TransactionExplorerConditionOperatorType.LongitudeBetween);
    public static readonly LongitudeNotBetween = new TransactionExplorerConditionOperator('Longitude is not between', TransactionExplorerConditionOperatorType.LongitudeNotBetween);

    public readonly name: string;
    public readonly value: TransactionExplorerConditionOperatorType;

    private constructor(name: string, value: TransactionExplorerConditionOperatorType) {
        this.name = name;
        this.value = value;

        TransactionExplorerConditionOperator.allInstances.push(this);
        TransactionExplorerConditionOperator.allInstancesByValue[value] = this;
    }

    public static values(): TransactionExplorerConditionOperator[] {
        return TransactionExplorerConditionOperator.allInstances;
    }

    public static valueOf(value: string): TransactionExplorerConditionOperator | undefined {
        return TransactionExplorerConditionOperator.allInstancesByValue[value];
    }
}

export enum TransactionExplorerChartTypeValue {
    Pie = 'pie',
    ColumnStacked = 'columnStacked',
    Column100PercentStacked = 'column100%Stacked',
    ColumnGrouped = 'columnGrouped',
    LineGrouped = 'lineGrouped',
    AreaStacked = 'areaStacked',
    Area100PercentStacked = 'area100%Stacked',
    BubbleGrouped = 'bubbleGrouped',
    Radar = 'radar'
}

export class TransactionExplorerChartType implements NameValue {
    private static readonly allInstances: TransactionExplorerChartType[] = [];
    private static readonly allInstancesByValue: Record<string, TransactionExplorerChartType> = {};

    public static readonly Pie = new TransactionExplorerChartType('Pie Chart', TransactionExplorerChartTypeValue.Pie, false);
    public static readonly Radar = new TransactionExplorerChartType('Radar Chart', TransactionExplorerChartTypeValue.Radar, false);
    public static readonly ColumnStacked = new TransactionExplorerChartType('Column Chart (Stacked)', TransactionExplorerChartTypeValue.ColumnStacked, true);
    public static readonly Column100PercentStacked = new TransactionExplorerChartType('Column Chart (100% Stacked)', TransactionExplorerChartTypeValue.Column100PercentStacked, true);
    public static readonly ColumnGrouped = new TransactionExplorerChartType('Column Chart (Grouped)', TransactionExplorerChartTypeValue.ColumnGrouped, true);
    public static readonly LineGrouped = new TransactionExplorerChartType('Line Chart (Grouped)', TransactionExplorerChartTypeValue.LineGrouped, true);
    public static readonly AreaStacked = new TransactionExplorerChartType('Area Chart (Stacked)', TransactionExplorerChartTypeValue.AreaStacked, true);
    public static readonly Area100PercentStacked = new TransactionExplorerChartType('Area Chart (100% Stacked)', TransactionExplorerChartTypeValue.Area100PercentStacked, true);
    public static readonly BubbleGrouped = new TransactionExplorerChartType('Bubble Chart (Grouped)', TransactionExplorerChartTypeValue.BubbleGrouped, true);

    public static readonly Default = TransactionExplorerChartType.Pie;

    public readonly name: string;
    public readonly value: TransactionExplorerChartTypeValue;
    public readonly seriesDimensionRequired: boolean;

    private constructor(name: string, value: TransactionExplorerChartTypeValue, seriesDimensionRequired: boolean) {
        this.name = name;
        this.value = value;
        this.seriesDimensionRequired = seriesDimensionRequired;

        TransactionExplorerChartType.allInstances.push(this);
        TransactionExplorerChartType.allInstancesByValue[value] = this;
    }

    public static values(): TransactionExplorerChartType[] {
        return TransactionExplorerChartType.allInstances;
    }

    public static valueOf(value: string): TransactionExplorerChartType | undefined {
        return TransactionExplorerChartType.allInstancesByValue[value];
    }
}

export enum TransactionExplorerDataDimensionType {
    None = 'none',
    Query = 'query',
    DateTime = 'dateTime',
    DateTimeByYearMonthDay = 'dateTimeByYearMonthDay',
    DateTimeByYearMonth = 'dateTimeByYearMonth',
    DateTimeByYearQuarter = 'dateTimeByYearQuarter',
    DateTimeByYear = 'dateTimeByYear',
    DateTimeByFiscalYear = 'dateTimeByFiscalYear',
    DateTimeByDayOfWeek = 'dateTimeByDayOfWeek',
    DateTimeByDayOfMonth = 'dateTimeByDayOfMonth',
    DateTimeByMonthOfYear = 'dateTimeByMonthOfYear',
    DateTimeByQuarterOfYear = 'dateTimeByQuarterOfYear',
    DateTimeByHourOfDay = 'dateTimeByHourOfDay',
    TimezoneOffset = 'timezoneOffset',
    TransactionType = 'transactionType',
    SourceAccount = 'sourceAccount',
    SourceAccountCategory = 'sourceAccountCategory',
    SourceAccountCurrency = 'sourceAccountCurrency',
    DestinationAccount = 'destinationAccount',
    DestinationAccountCategory = 'destinationAccountCategory',
    DestinationAccountCurrency = 'destinationAccountCurrency',
    SourceAmount = 'sourceAmount',
    DestinationAmount = 'destinationAmount',
    PrimaryCategory = 'primaryCategory',
    SecondaryCategory = 'secondaryCategory'
}

export class TransactionExplorerDataDimension implements NameValue {
    private static readonly allInstances: TransactionExplorerDataDimension[] = [];
    private static readonly allInstancesByValue: Record<string, TransactionExplorerDataDimension> = {};

    public static readonly None = new TransactionExplorerDataDimension('None', TransactionExplorerDataDimensionType.None);
    public static readonly Query = new TransactionExplorerDataDimension('Query', TransactionExplorerDataDimensionType.Query);
    public static readonly DateTime = new TransactionExplorerDataDimension('Transaction Time', TransactionExplorerDataDimensionType.DateTime);
    public static readonly DateTimeByYearMonthDay = new TransactionExplorerDataDimension('Transaction Date', TransactionExplorerDataDimensionType.DateTimeByYearMonthDay);
    public static readonly DateTimeByYearMonth = new TransactionExplorerDataDimension('Transaction Year-Month', TransactionExplorerDataDimensionType.DateTimeByYearMonth);
    public static readonly DateTimeByYearQuarter = new TransactionExplorerDataDimension('Transaction Year-Quarter', TransactionExplorerDataDimensionType.DateTimeByYearQuarter);
    public static readonly DateTimeByYear = new TransactionExplorerDataDimension('Transaction Year', TransactionExplorerDataDimensionType.DateTimeByYear);
    public static readonly DateTimeByFiscalYear = new TransactionExplorerDataDimension('Transaction Fiscal Year', TransactionExplorerDataDimensionType.DateTimeByFiscalYear);
    public static readonly DateTimeByDayOfWeek = new TransactionExplorerDataDimension('Transaction Day of Week', TransactionExplorerDataDimensionType.DateTimeByDayOfWeek);
    public static readonly DateTimeByDayOfMonth = new TransactionExplorerDataDimension('Transaction Day of Month', TransactionExplorerDataDimensionType.DateTimeByDayOfMonth);
    public static readonly DateTimeByMonthOfYear = new TransactionExplorerDataDimension('Transaction Month of Year', TransactionExplorerDataDimensionType.DateTimeByMonthOfYear);
    public static readonly DateTimeByQuarterOfYear = new TransactionExplorerDataDimension('Transaction Quarter of Year', TransactionExplorerDataDimensionType.DateTimeByQuarterOfYear);
    public static readonly DateTimeByHourOfDay = new TransactionExplorerDataDimension('Transaction Hour of Day', TransactionExplorerDataDimensionType.DateTimeByHourOfDay);
    public static readonly TimezoneOffset = new TransactionExplorerDataDimension('Transaction Timezone', TransactionExplorerDataDimensionType.TimezoneOffset);
    public static readonly TransactionType = new TransactionExplorerDataDimension('Transaction Type', TransactionExplorerDataDimensionType.TransactionType);
    public static readonly SourceAccount = new TransactionExplorerDataDimension('Source Account', TransactionExplorerDataDimensionType.SourceAccount);
    public static readonly SourceAccountCategory = new TransactionExplorerDataDimension('Source Account Category', TransactionExplorerDataDimensionType.SourceAccountCategory);
    public static readonly SourceAccountCurrency = new TransactionExplorerDataDimension('Source Account Currency', TransactionExplorerDataDimensionType.SourceAccountCurrency);
    public static readonly DestinationAccount = new TransactionExplorerDataDimension('Destination Account', TransactionExplorerDataDimensionType.DestinationAccount);
    public static readonly DestinationAccountCategory = new TransactionExplorerDataDimension('Destination Account Category', TransactionExplorerDataDimensionType.DestinationAccountCategory);
    public static readonly DestinationAccountCurrency = new TransactionExplorerDataDimension('Destination Account Currency', TransactionExplorerDataDimensionType.DestinationAccountCurrency);
    public static readonly PrimaryCategory = new TransactionExplorerDataDimension('Primary Category', TransactionExplorerDataDimensionType.PrimaryCategory);
    public static readonly SecondaryCategory = new TransactionExplorerDataDimension('Secondary Category', TransactionExplorerDataDimensionType.SecondaryCategory);
    public static readonly SourceAmount = new TransactionExplorerDataDimension('Amount', TransactionExplorerDataDimensionType.SourceAmount);
    public static readonly DestinationAmount = new TransactionExplorerDataDimension('Transfer In Amount', TransactionExplorerDataDimensionType.DestinationAmount);

    public static readonly CategoryDimensionDefault = TransactionExplorerDataDimension.Query;
    public static readonly SeriesDimensionDefault = TransactionExplorerDataDimension.None;

    public readonly name: string;
    public readonly value: TransactionExplorerDataDimensionType;

    private constructor(name: string, value: TransactionExplorerDataDimensionType) {
        this.name = name;
        this.value = value;

        TransactionExplorerDataDimension.allInstances.push(this);
        TransactionExplorerDataDimension.allInstancesByValue[value] = this;
    }

    public static values(): TransactionExplorerDataDimension[] {
        return TransactionExplorerDataDimension.allInstances;
    }

    public static valueOf(value: string): TransactionExplorerDataDimension | undefined {
        return TransactionExplorerDataDimension.allInstancesByValue[value];
    }
}

export enum TransactionExplorerValueMetricType {
    TransactionCount = 'transactionCount',
    SourceAmountSum = 'sourceAmountSum',
    SourceAmountAverage = 'sourceAmountAverage',
    SourceAmountMedian = 'sourceAmountMedian',
    SourceAmount90thPercentile = 'source90thPercentileAmount',
    SourceAmountMinimum = 'sourceAmountMinimum',
    SourceAmountMaximum = 'sourceAmountMaximum',
    SourceAmountRange = 'sourceAmountRange',
    SourceAmountInterquartileRange = 'sourceAmountInterquartileRange',
    SourceAmountVariance = 'sourceAmountVariance',
    SourceAmountStandardDeviation = 'sourceAmountStandardDeviation',
    SourceAmountCoefficientOfVariation = 'sourceAmountCoefficientOfVariation'
}

export class TransactionExplorerValueMetric implements NameValue {
    private static readonly allInstances: TransactionExplorerValueMetric[] = [];
    private static readonly allInstancesByValue: Record<string, TransactionExplorerValueMetric> = {};

    public static readonly TransactionCount = new TransactionExplorerValueMetric('Transaction Count', TransactionExplorerValueMetricType.TransactionCount, false, true);
    public static readonly SourceAmountSum = new TransactionExplorerValueMetric('Total Amount', TransactionExplorerValueMetricType.SourceAmountSum, true, true);
    public static readonly SourceAmountAverage = new TransactionExplorerValueMetric('Average Amount', TransactionExplorerValueMetricType.SourceAmountAverage, true, true);
    public static readonly SourceAmountMedian = new TransactionExplorerValueMetric('Median Amount', TransactionExplorerValueMetricType.SourceAmountMedian, true, true);
    public static readonly SourceAmount90thPercentile = new TransactionExplorerValueMetric('90th Percentile Amount', TransactionExplorerValueMetricType.SourceAmount90thPercentile, true, true);
    public static readonly SourceAmountMinimum = new TransactionExplorerValueMetric('Minimum Amount', TransactionExplorerValueMetricType.SourceAmountMinimum, true, true);
    public static readonly SourceAmountMaximum = new TransactionExplorerValueMetric('Maximum Amount', TransactionExplorerValueMetricType.SourceAmountMaximum, true, true);
    public static readonly SourceAmountRange = new TransactionExplorerValueMetric('Range (Max - Min)', TransactionExplorerValueMetricType.SourceAmountRange, true, true);
    public static readonly SourceAmountInterquartileRange = new TransactionExplorerValueMetric('Interquartile Range (Q3 - Q1)', TransactionExplorerValueMetricType.SourceAmountInterquartileRange, true, true);
    public static readonly SourceAmountVariance = new TransactionExplorerValueMetric('Variance', TransactionExplorerValueMetricType.SourceAmountVariance, false, false);
    public static readonly SourceAmountStandardDeviation = new TransactionExplorerValueMetric('Standard Deviation', TransactionExplorerValueMetricType.SourceAmountStandardDeviation, false, false);
    public static readonly SourceAmountCoefficientOfVariation = new TransactionExplorerValueMetric('Coefficient of Variation', TransactionExplorerValueMetricType.SourceAmountCoefficientOfVariation, false, false);

    public static readonly Default = TransactionExplorerValueMetric.SourceAmountSum;

    public readonly name: string;
    public readonly value: TransactionExplorerValueMetricType;
    public readonly isAmount: boolean;
    public readonly supportSum: boolean;

    private constructor(name: string, value: TransactionExplorerValueMetricType, isAmount: boolean, supportSum: boolean) {
        this.name = name;
        this.value = value;
        this.isAmount = isAmount;
        this.supportSum = supportSum;

        TransactionExplorerValueMetric.allInstances.push(this);
        TransactionExplorerValueMetric.allInstancesByValue[value] = this;
    }

    public static values(): TransactionExplorerValueMetric[] {
        return TransactionExplorerValueMetric.allInstances;
    }

    public static valueOf(value: string): TransactionExplorerValueMetric | undefined {
        return TransactionExplorerValueMetric.allInstancesByValue[value];
    }
}

export const DEFAULT_TRANSACTION_EXPLORER_DATE_RANGE: DateRange = DateRange.ThisMonth;