import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
// import User from 'App/Models/User';
// import Role from 'App/Models/Role';
// import Database from '@ioc:Adonis/Lucid/Database';
import License from 'App/Models/License';
// import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
// import CreateUserValidator from 'App/Validators/CreateUserValidator';
// import UpdateUserValidator from 'App/Validators/UpdateUserValidator';
// import { RenderResponse } from '@ioc:EidelLev/Inertia';
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';

enum TitleTypes {
    Main = 'Main',
    Sub = 'Sub',
    Alternative = 'Alternative',
    Translated = 'Translated',
    Other = 'Other',
}

enum DescriptionTypes {
    Abstract = 'Abstract',
    Methods = 'Methods',
    Series_information = 'Series_information',
    Technical_info = 'Technical_info',
    Translated = 'Translated',
    Other = 'Other',
}

export default class DatasetController {
    public async create({ inertia }: HttpContextContract) {
        const licenses = await License.query().select('id', 'name_long').pluck('name_long', 'id');

        const doctypes = {
            analysisdata: { label: 'Analysis', value: 'analysisdata' },
            measurementdata: { label: 'Measurements', value: 'measurementdata' },
            monitoring: 'Monitoring',
            remotesensing: 'Remote Sensing',
            gis: 'GIS',
            models: 'Models',
            mixedtype: 'Mixed Type',
        };

        // const titletypes = {
        //     Sub: 'Sub',
        //     Alternative: 'Alternative',
        //     Translated: 'Translated',
        //     Other: 'Other',
        // };

        // const languages = await Database.from('languages').select('*').where('active', true);
        return inertia.render('Submitter/Dataset/Create', {
            licenses: licenses,
            doctypes: doctypes,
            titletypes: Object.values(TitleTypes).filter((x) => x.valueOf() !== 'Main'),
            descriptiontypes: Object.values(DescriptionTypes).filter((x) => x.valueOf() !== 'Abstract'),
            // descriptiontypes: DescriptionTypes
        });
    }

    public async firstStep({ request, response }: HttpContextContract) {
        const newDatasetSchema = schema.create({
            language: schema.string({ trim: true }, [
                rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
            ]),
            licenses: schema.array([rules.minLength(1)]).members(schema.number()), // define at least one license for the new dataset
            rights: schema.string([rules.equalTo('true')]),
        });

        try {
            //  Step 2 - Validate request body against  the schema
            
            await request.validate({ schema: newDatasetSchema, messages: this.messages });
            // console.log({ payload });
        } catch (error) {
            // Step 3 - Handle errors
            // return response.badRequest(error.messages);
            throw error;
        }
        return response.redirect().back();
    }

    public async secondStep({ request, response }: HttpContextContract) {
        const newDatasetSchema = schema.create({
            language: schema.string({ trim: true }, [
                rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
            ]),
            licenses: schema.array([rules.minLength(1)]).members(schema.number()), // define at least one license for the new dataset
            type: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
            creating_corporation: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
            titles: schema.array([rules.minLength(1)]).members(
                schema.object().members({
                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
                    type: schema.enum(Object.values(TitleTypes)),
                    language: schema.string({ trim: true }, [rules.minLength(2), rules.maxLength(255)]),
                }),
            ),
            descriptions: schema.array([rules.minLength(1)]).members(
                schema.object().members({
                    value: schema.string({ trim: true }, [rules.minLength(3), rules.maxLength(255)]),
                    type: schema.enum(Object.values(DescriptionTypes)),
                    language: schema.string({ trim: true }, [rules.minLength(2), rules.maxLength(255)]),
                }),
            ),
        });

        try {
            //  Step 2 - Validate request body against  the schema
            await request.validate({ schema: newDatasetSchema, messages: this.messages });
            // console.log({ payload });
        } catch (error) {
            // Step 3 - Handle errors
            // return response.badRequest(error.messages);
            throw error;
        }
        return response.redirect().back();
    }

    // public async store({ request, response, session }: HttpContextContract) {
    // 	// node ace make:validator CreateUser
    // 	try {
    // 		//  Step 2 - Validate request body against  the schema
    // 		await request.validate(CreateUserValidator);
    // 		// console.log({ payload });
    // 	} catch (error) {
    // 		// Step 3 - Handle errors
    // 		// return response.badRequest(error.messages);
    // 		throw error;
    // 	}
    // 	const input = request.only(['login', 'email', 'password']);
    // 	const user = await User.create(input);
    // 	if (request.input('roles')) {
    // 		const roles: Array<number> = request.input('roles');
    // 		await user.related('roles').attach(roles);
    // 	}

    // 	session.flash('message', 'User has been created successfully');
    // 	return response.redirect().toRoute('user.index');
    // }

    public messages: CustomMessages = {
		'minLength': '{{ field }} must be at least {{ options.minLength }} characters long',
		'maxLength': '{{ field }} must be less then {{ options.maxLength }} characters long',
		'required': '{{ field }} is required',
		'unique': '{{ field }} must be unique, and this value is already taken',
		// 'confirmed': '{{ field }} is not correct',
		'licences.minLength': 'at least {{ options.minLength }} permission must be defined',
		'licences.*.number': 'Define roles as valid numbers',
        'rights.equalTo': 'you must agree to continue',
        
        'titles.0.value.minLength': 'Main Title  must be at least {{ options.minLength }} characters long',
        'titles.0.value.required': 'Main Title is required',
        'titles.*.value.required': 'Additional title is required, if defined',
        'titles.*.type.required': 'Additional title type is required',
        'titles.*.language.required': 'Additional title language is required',
        
        'descriptions.0.value.minLength': 'Main Abstract  must be at least {{ options.minLength }} characters long',
        'descriptions.0.value.required': 'Main Abstract is required',
        'descriptions.*.value.required': 'Additional description is required, if defined',
        'descriptions.*.type.required': 'Additional description type is required',
        'descriptions.*.language.required': 'Additional description language is required',
	};
}