import {ServerFactory} from './form.server.records';
import {ClientFactory} from './form.client.records';

import * as ServerModel from './form.server.models';
import * as ClientModel from './form.client.models';

import {ProjectionBuilder} from '@redarrowlabs/modeljx';

import * as Immutable from 'immutable';

const MapPascalToCamelCase = (x: string) => x.charAt(0).toLowerCase() + x.slice(1);

const FormMetaResult_to_Model = ProjectionBuilder
    .defineProjection<ServerModel.FormMetadata, ClientModel.FormMetadata>(
        ServerFactory.formMetadataRecord,
        ClientFactory.formMetadataRecord
    )
    .withMapping(MapPascalToCamelCase)
    .build();

const SectionMetaResult_to_Model = ProjectionBuilder
    .defineProjection<ServerModel.SectionMetadata, ClientModel.SectionMetadata>(
        ServerFactory.sectionMetadataRecord,
        ClientFactory.sectionMetadataRecord
    )
    .withMapping(MapPascalToCamelCase)
    .build();

const OptionsResult_to_Model = ProjectionBuilder
    .defineProjection<ServerModel.DropdownOption, ClientModel.DropdownOption>(
        ServerFactory.dropdownOptionRecord,
        ClientFactory.dropdownOptionRecord
    )
    .withMapping(MapPascalToCamelCase)
    .build();

const LayoutResult_to_Model = ProjectionBuilder
    .defineProjection<ServerModel.FormInput, ClientModel.FormInput>(
        ServerFactory.formInputRecord,
        ClientFactory.formInputRecord
    )
    .withMapping(MapPascalToCamelCase)
    .override({
        fromProperty: (x: ServerModel.FormInput) => x.Options,
        toProperty: (x: ClientModel.FormInput) => x.options,
        use: OptionsResult_to_Model
    })
    .build();

const SectionResult_to_Model = ProjectionBuilder
    .defineProjection<ServerModel.Section, ClientModel.Section>(
        ServerFactory.sectionRecord,
        ClientFactory.sectionRecord
    )
    .withMapping(MapPascalToCamelCase)
    .override({
        forProperty: (x: ServerModel.Section) => x.meta,
        use: SectionMetaResult_to_Model
    })
    .override({
        forProperty: (x: ServerModel.Section) => x.layout,
        use: LayoutResult_to_Model
    })
    .build();

export const FormResult_to_Model = ProjectionBuilder
    .defineProjection<ServerModel.FormDefinition, ClientModel.FormDefinition>(
        ServerFactory.formDefinitionRecord,
        ClientFactory.formDefinitionRecord
    )
    .withMapping(MapPascalToCamelCase)
    .override({
        forProperty: (x: ServerModel.FormDefinition) => x.meta,
        use: FormMetaResult_to_Model
    })
    .override({
        forProperty: (from: ServerModel.FormDefinition) => from.sections,
        use: SectionResult_to_Model
    })
    .build();