export function timeIntervalCodec(fmt: string): Codec<TimeInterval,JsonObject> {
    var _timeCodec = composeCodecs(timeCodec(fmt), _NULL_AS_WILDCARD);
    return recordCodec<TimeInterval>({
        start: _timeCodec,
        end: _timeCodec
    }, (args) => new TimeInterval(args))
}

export const STAFF_AVAILABILITY_CODEC: Codec<StaffAvailability, JsonObject> = (() => {
    var intervalCodec = timeIntervalCodec('HH:mm');
    return recordCodec<StaffAvailability>({
        mon: intervalCodec,
        tue: intervalCodec,
        wed: intervalCodec,
        thu: intervalCodec,
        fri: intervalCodec
    }, (args) => new StaffAvailability(args));
})();

export class EnergyAccount extends _ENERGY_ACCOUNT_RECORD {
    type: EnergyAccountType;
    retailer: EnergyRetailer;
    accountNumber: string;

    isResidential: boolean;
    isCorrectName: boolean;
    isCorrectAddress: boolean;

    constructor(args?: {
        type: EnergyAccountType,
        retailer?: EnergyRetailer,
        accountNumber?: string,
    }) {
        super(args);
    }

    get isValid(): boolean {
        return this.retailer !== 'NOT_DISCLOSED'
            && this.accountNumber !== '';
    }

}

export const ENERGY_ACCOUNT_CODEC = recordCodec<EnergyAccount>({
    type: ENERGY_ACCOUNT_TYPE_CODEC,
    retailer: ENERGY_RETAILER_CODEC,
    accountNumber: str,
}, (args: any) => new EnergyAccount(args));

    }

    get isExpired(): boolean {
        return moment(this.expires).isBefore(moment());
    }

    checkForAlertLabels():Iterable<any, AlertLabel|Iterable<any, any>> {
        return _TERM_LABELS
            .filter((label) => label.test(this));
    }
}

export const MEMBER_TERM_CODEC = recordCodec<MemberTerm>(
    {
        type: MEMBER_TERM_TYPE_CODEC,
        joined: dateTime,
        renewed: dateTime,
        expires: dateTime
    },
    (args) => new MemberTerm(args)
);

const _TERM_LABELS = List<AlertLabel>([
    {
        text: 'membership expired',
        severity: LabelSeverity.Warning,
        tooltip: 'Membership term has expired',
        test: (term: MemberTerm) => term.isExpired
    }
]);

});

export class EnergyAccountBill extends _BILL_RECORD {
    account: EnergyAccount;
    value: number;

    constructor(args?: {
        account?: EnergyAccount,
        value?: number,
    }) {
        super(args);
    }

    get isValid(): boolean {
        return this.account.isValid
            && this.value >= 0;

    }
}

export const ENERGY_ACCOUNT_BILL_CODEC = recordCodec<EnergyAccountBill>(
    {
        account: ENERGY_ACCOUNT_CODEC,
        value: num
    },
    (args: any) => new EnergyAccountBill(args)
);

import {Iterable, List, Record} from 'immutable';

import {recordCodec} from 'caesium-model/json_codecs';
import {AlertLabel, CheckForAlertLabels} from "../../../utils/alert_label/alert_label";

import {ResidentialStability, RESIDENTIAL_STABILITY_CODEC} from './residential_stability.model';
import {ResidenceType, RESIDENCE_TYPE_CODEC} from './residence_type.model';

const _RESIDENTIAL_STATUS_RECORD = Record({
    stability: 'NOT_DISCLOSED',
    type: 'NOT_DISCLOSED'
});

export class ResidentialStatus extends _RESIDENTIAL_STATUS_RECORD implements CheckForAlertLabels {
    stability: ResidentialStability;
    type: ResidenceType;

    checkForAlertLabels(): Iterable.Indexed<AlertLabel|Iterable.Indexed<any>> {
        //TODO: Any labels emitted?
        return List<AlertLabel>();
    }
}

export const RESIDENTIAL_STATUS_CODEC = recordCodec<ResidentialStatus>({
    stability: RESIDENTIAL_STABILITY_CODEC,
    type: RESIDENCE_TYPE_CODEC
}, (args) => new ResidentialStatus(args));

    benefitType: BenefitType;
    benefitOtherDescription: string;
    proofOfLowIncome: ProofOfLowIncome;

    checkForAlertLabels():Iterable.Indexed<AlertLabel|Iterable.Indexed<any>> {
        return _INCOME_INFO_LABELS
            .filter((label) => label.test(this))
            .toIndexedSeq();
    }
}

export const INCOME_CODEC = recordCodec<Income>(
    {
        type: INCOME_TYPE_CODEC,
        benefitType: BENEFIT_TYPE_CODEC,
        benefitOtherDescriptions: str,
        proofOfLowIncome: PROOF_OF_LOW_INCOME_CODEC
    },
    (args) => new Income(args)
);

const _INCOME_INFO_LABELS = List<AlertLabel>([
    {
        text: 'No proof of low income',
        severity: LabelSeverity.Warning,
        tooltip: 'Request low income card on member contact',
        test: (income:Income) => (income.proofOfLowIncome === 'NO_PROOF')
    }
]);

import {Record} from 'immutable';
import {str, recordCodec} from "caesium-model/json_codecs";

const _ADDRESS_RECORD = Record({street: '', city: '', postcode: ''});

export class Address extends _ADDRESS_RECORD {
    street: string;
    city: string;
    postcode: string;
}

export const ADDRESS_CODEC = recordCodec<Address>({
    street: str,
    city: str,
    postcode: str
}, (args) => new Address(args));

    isPBS: false,
});

export class ChemistPrescription extends _CHEMIST_PRESCRIPTION_RECORD {
    /**
     * The name of the medication, as printed on the description.
     */
    name: string;

    /**
     * Is the prescription a PBS prescription.
     */
    isPBS: boolean;

    /**
     * The cost of the medicine, including any PBS discounts.
     */
    value: number;


    constructor(args?: {isPBS: boolean}) {
        super(args);
    }
}

export const CHEMIST_PRESCRIPTION_CODEC = recordCodec<ChemistPrescription>({
    name: str,
    isPBS: bool
}, (args: any) => new ChemistPrescription(args));

import {Record} from 'immutable';

import {recordCodec} from 'caesium-model/json_codecs';

export const _REFERRAL_RECORD = Record({});

export class Referral extends _REFERRAL_RECORD {

}

export const REFERRAL_CODEC = recordCodec<Referral>({

    },
    (args: any) => new Referral(args)
);