import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
import { IbGibSpaceAny } from '@ibgib/core-gib/dist/witness/space/space-base-v1.mjs';
// import { SecretModalFormComponent } from '../modals/secret-modal-form/secret-modal-form.component';
// import { EncryptionModalFormComponent } from '../modals/encryption-modal-form/encryption-modal-form.component';
// import { OuterspaceModalFormComponent } from '../modals/outerspace-modal-form/outerspace-modal-form.component';
// import { UpdatePicModalFormComponent, UpdatePicPromptResult } from '../modals/update-pic-modal-form/update-pic-modal-form.component';
// import { UpdateCommentModalFormComponent, UpdateCommentPromptResult } from '../modals/update-comment-modal-form/update-comment-modal-form.component';
// import { EncryptionData_V1 } from '@ibgib/core-gib/dist/common/encrypt/encrypt-types.mjs';
// import { OuterSpaceIbGib } from '@ibgib/core-gib/dist/witness/space/outer-space/outer-space-types.mjs';
// import { PicIbGib_V1 } from '@ibgib/core-gib/dist/common/pic/pic-types.mjs';
// import { RobbotIbGib_V1 } from '@ibgib/core-gib/dist/witness/robbot/robbot-types.mjs';
// import {
//     RobbotModalFormComponent, RobbotPromptResult
// } from '@ibgib/core-gib/dist/modals/robbot-modal-form/robbot-modal-form.component';
// import { AppIbGib_V1 } from '@ibgib/core-gib/dist/witness/app/app-types.mjs';
// import {
//     AppModalFormComponent, AppPromptResult
// } from '@ibgib/core-gib/dist../modals/app-modal-form/app-modal-form.component';
// import { clearDoCancelModalOnBackButton, registerCancelModalOnBackButton } from '@ibgib/core-gib/dist./utils';
// import { CommentIbGib_V1 } from '@ibgib/core-gib/dist/common/comment/comment-types.mjs';
// import { SECRET_REL8N_NAME } from '@ibgib/core-gib/dist/common/encrypt/encrypt-constants.mjs';

import { GLOBAL_LOG_A_LOT } from '../constants.mjs';
import { alertUser, promptForConfirm, promptForText } from '../helpers.web.mjs';

const logalot = GLOBAL_LOG_A_LOT || false;


/**
 * Wrapper for alerting via atow capacitor modals.
 *
 * @returns FUNCTION that alerts (doesn't actually do the alert)
 */
export function getFnAlert(): ({ title, msg }: { title: string, msg: string }) => Promise<void> {
    return async ({ title, msg }: { title: string, msg: string }) => {
        // await Dialog.alert({ title, message: msg });
        // const titlePlusMsg = `${title}: ${msg}`;
        // console.log(titlePlusMsg);
        // alert(titlePlusMsg)
        await alertUser({ msg, title });
    };
}

/**
 * Wrapper for prompting via custom dialog function.
 *
 * @returns FUNCTION that prompts (doesn't actually do the prompt, just creates
 * the function that will)
 */
export function getFnPrompt(): ({ title, msg }: { title: string, msg: string }) => Promise<string | null> {
    return async ({ title, msg }: { title: string, msg: string }) => {
        const lc = `[${getFnPrompt.name}]`;
        let answer: string;
        try {
            if (!msg) { throw new Error(`msg required. (E: c39d1656b6b803e11bad46efe15b6823)`); }

            answer = await promptForText({ title, msg });

            // const titlePlusMsg = `${title}: ${msg}`;
            // console.log(`${lc} ${titlePlusMsg}`);
            // answer = window.prompt(titlePlusMsg) ?? '';
            // if (logalot) { console.log(`${lc} answer: ${answer} (I: 89e4379f368c136a31e52107447b7b24)`); }

            // const rl = readline.createInterface({ input: stdin, output: stdout });
            // try {
            //     const text = title ? `\n# ${title}:\n\n${msg}\n` : `${msg}\n`;
            //     answer = await rl.question(text);
            //     if (logalot) { console.log(`${lc} text: ${text}. answer: ${answer} (I: 7f0375b3abd7eba9c75636d31bbca323)`); }
            // } catch (error) {
            //     throw error;
            // } finally {
            //     rl.close();
            // }
        } catch (error) {
            console.error(`${lc} ${extractErrorMsg(error)}`);
            throw error;
        }
        return answer || answer === '' ? answer : null;
    };
}

/**
 * Wrapper for confirming via commandline/terminal prompt.
 *
 * @returns FUNCTION that prompts (doesn't actually do the prompt)
 */
export function getFnConfirm():
    ({ title, msg, okButtonTitle, cancelButtonTitle }:
        { title: string, msg: string, okButtonTitle?: string, cancelButtonTitle?: string }) => Promise<boolean> {
    return async ({ title, msg, okButtonTitle, cancelButtonTitle }:
        { title: string, msg: string, okButtonTitle?: string, cancelButtonTitle?: string }) => {
        okButtonTitle ||= 'yes';
        cancelButtonTitle ||= 'no';

        if (okButtonTitle === cancelButtonTitle) { throw new Error(`okButtonTitle (${okButtonTitle}) must be different than cancelButtonTitle (${cancelButtonTitle}) (E: 254e92fed2e99edc362de337e8bf3123)`); }
        // if (okButtonTitle[0] === cancelButtonTitle[0]) { throw new Error(`okButtonTitle (${okButtonTitle}) must start with a different character than cancelButtonTitle (${cancelButtonTitle}) (E: 8bdd34b0d90f479399d911af58df9190)`); }

        let result = await promptForConfirm({
            msg,
            yesLabel: okButtonTitle,
            noLabel: cancelButtonTitle,
        });

        return result;

        // const promptFn = getFnPrompt();
        // let result: string | null = null;
        // do {
        //     // result = await promptFn({ title, msg: `${msg} (${okButtonTitle}/${cancelButtonTitle})` });
        //     result = await promptForConfirm({
        //         title,
        //         msg: `${msg} (${okButtonTitle}/${cancelButtonTitle})`
        //     }) ?? null;
        //     result = result ? result!.toLowerCase() : null;
        // } while (!result);

        // if (result === okButtonTitle![0].toLowerCase()) { result = okButtonTitle!; }
        // return result === okButtonTitle;
    };
}

/**
 * Prompts the user for a password using an ionic capacitor (atow) alert
 * controller with an input of type `'password'`.
 *
 *
 *
 * @returns either the password or null if cancelled
 */
export function getFnPromptPassword(): (title: string, msg: string) => Promise<string | null> {
    const lc = `[${getFnPromptPassword.name}]`;
    try {
        throw new Error(`not implemented yet. i have added PromptPasswordFunction type in core-gib/core-types (E: 78c7dbb8958f8f353730d0dbb86b5423)`);
        // if (!alertController) { throw new Error('alertController required.'); }
        // let fnPromptPassword = async (title: string, msg: string) => {
        //     const alert = await alertController.create({
        //         header: title,
        //         message: msg,
        //         inputs: [
        //             { name: 'password', type: 'password', label: 'Password: ', },
        //         ],
        //         buttons: ['OK', 'Cancel'],
        //     });
        //     await alert.present();
        //     let result = await alert.onDidDismiss();
        //     if (result?.data?.values?.password) {
        //         return result!.data!.values!.password;
        //     } else {
        //         return null;
        //     }
        // };
        // return fnPromptPassword;
    } catch (error) {
        console.error(`${lc} ${extractErrorMsg(error)}`);
        throw error;
    }
}

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to create an secret ibgib. If the user chooses to save, then the
 * modal will create the secret ibgib, save the transform result in the
 * given `space` (atow this is the local user space), and return the new
 * secret ibgib.
 */
export function getFn_promptCreateSecretIbGib(
): (space: IbGibSpaceAny) => Promise<IbGib_V1 | undefined> {
    const lc = `[${getFn_promptCreateSecretIbGib.name}]`;
    return async (space: IbGibSpaceAny) => {
        throw new Error(`not impl yet (E: 990b79f9b8c2302163cc656deceaf923)`);
        // /** hacked untyped document reference to hack a solution to the back button leaving modals open. */
        // try {
        //     const modal = await common.modalController.create({
        //         component: SecretModalFormComponent,
        //     });
        //     // have to register/clear modal for cancelling in case the user
        //     // presses the back button while the modal is still visible
        //     registerCancelModalOnBackButton(modal);
        //     await modal.present();
        //     let resModal = await modal.onWillDismiss();
        //     // clear the cancel since it dismissed naturally
        //     clearDoCancelModalOnBackButton();
        //     if (resModal.data) {
        //         const resNewSecret = <TransformResult<SecretIbGib_V1>>resModal.data;
        //         await common.ibgibs.persistTransformResult({ resTransform: resNewSecret, space });
        //         const addr = getIbGibAddr({ ibGib: resNewSecret.newIbGib });
        //         if (logalot) { console.log(`${lc} created secret. addr: ${addr}`); }
        //         await common.ibgibs.rel8ToSpecialIbGib({
        //             type: "secrets",
        //             rel8nName: SECRET_REL8N_NAME,
        //             ibGibsToRel8: [resNewSecret.newIbGib],
        //             space,
        //         });
        //         return resNewSecret.newIbGib;
        //     } else {
        //         // didn't create one
        //         console.warn(`${lc} didn't create at this time.`);
        //         return undefined;
        //     }
        // } catch (error) {
        //     console.error(`${lc} error: ${extractErrorMsg(error)}`);
        //     return undefined;
        // }
    }
}

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to create an encryption ibgib. If the user chooses to save, then the
 * modal will create the encryption ibgib, save the transform result in the
 * given `space` (atow this is the local user space), and return the new
 * encryption ibgib.
 */
export function getFn_promptCreateEncryptionIbGib(
    // common: CommonService,
): (space: IbGibSpaceAny) => Promise<IbGib_V1 | undefined> {
    throw new Error(`not impl yet (E: 69c7d552de7318a97457363adfd34f23)`);
    // const lc = `[${getFn_promptCreateEncryptionIbGib.name}]`;
    // return async (space: IbGibSpaceAny) => {
    //     try {
    //         const modal = await common.modalController.create({
    //             component: EncryptionModalFormComponent,
    //         });
    //         // have to register/clear modal for cancelling in case the user
    //         // presses the back button while the modal is still visible
    //         registerCancelModalOnBackButton(modal);
    //         await modal.present();
    //         let resModal = await modal.onWillDismiss();
    //         // clear the cancel since it dismissed naturally
    //         clearDoCancelModalOnBackButton();
    //         if (resModal.data) {
    //             const resNewEncryption = <TransformResult<IbGib_V1<EncryptionData_V1>>>resModal.data;
    //             await common.ibgibs.persistTransformResult({ resTransform: resNewEncryption, space });
    //             const addr = getIbGibAddr({ ibGib: resNewEncryption.newIbGib });
    //             if (logalot) { console.log(`${lc} created encryption. addr: ${addr}`); }
    //             return resNewEncryption.newIbGib;
    //         } else {
    //             // didn't create one
    //             console.warn(`${lc} didn't create at this time.`);
    //             return undefined;
    //         }
    //     } catch (error) {
    //         console.error(`${lc} error: ${extractErrorMsg(error)}`);
    //         return undefined;
    //     }
    // }
}

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to create an outerspace ibgib. If the user chooses to save, then the
 * modal will create the outerspace ibgib, save the transform result in the
 * given `space` (atow this is the local user space), and return the new
 * outerspace ibgib.
 */
export function getFn_promptCreateOuterSpaceIbGib(
    // common: CommonService,
): (space: IbGibSpaceAny) => Promise<IbGib_V1 | undefined> {
    throw new Error(`not impl yet (E: e48ef8a7b4252cfe795dde791de99523)`);
    // const lc = `[${getFn_promptCreateOuterSpaceIbGib.name}]`;
    // return async (space: IbGibSpaceAny) => {
    //     try {
    //         const modal = await common.modalController.create({
    //             component: OuterspaceModalFormComponent,
    //         });
    //         // have to register/clear modal for cancelling in case the user
    //         // presses the back button while the modal is still visible
    //         registerCancelModalOnBackButton(modal);
    //         await modal.present();
    //         let resModal = await modal.onWillDismiss();
    //         // clear the cancel since it dismissed naturally
    //         clearDoCancelModalOnBackButton();
    //         if (resModal.data) {
    //             const resOuterSpace = <TransformResult<OuterSpaceIbGib>>resModal.data;
    //             await common.ibgibs.persistTransformResult({ resTransform: resOuterSpace, space });
    //             const addr = getIbGibAddr({ ibGib: resOuterSpace.newIbGib });
    //             if (logalot) { console.log(`${lc} created outerspace. addr: ${addr}`); }
    //             return resOuterSpace.newIbGib;
    //         } else {
    //             // didn't create one
    //             console.warn(`${lc} didn't create outerspace at this time.`);
    //             return undefined;
    //         }
    //     } catch (error) {
    //         console.error(`${lc} error: ${extractErrorMsg(error)}`);
    //         return undefined;
    //     }
    // }
}

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to mutate a pic ibgib. If the user chooses to save, then the modal will
 * perform the mutation, save the transform result in the given `space`, and
 * return the new pic ibgib.
 */
// export function getFn_promptUpdatePicIbGib(
//     common: CommonService,
// ): (space: IbGibSpaceAny, picIbGib: PicIbGib_V1) => Promise<UpdatePicPromptResult | undefined> {
//     const lc = `[${getFn_promptUpdatePicIbGib.name}]`;
//     return async (space: IbGibSpaceAny, picIbGib: PicIbGib_V1) => {
//         try {
//             const modal = await common.modalController.create({
//                 component: UpdatePicModalFormComponent,
//                 componentProps: { picIbGib, space },
//             });
//             // have to register/clear modal for cancelling in case the user
//             // presses the back button while the modal is still visible
//             registerCancelModalOnBackButton(modal);
//             await modal.present();
//             let resModal = await modal.onWillDismiss();
//             // clear the cancel since it dismissed naturally
//             clearDoCancelModalOnBackButton();
//             if (resModal.data) {
//                 const result = <UpdatePicPromptResult>resModal.data;
//                 const [resCreatePic, _resCreateBin] = result;
//                 const addr = getIbGibAddr({ ibGib: resCreatePic.newIbGib });
//                 if (logalot) { console.log(`${lc} updated pic. addr: ${addr}`); }
//                 return result;
//             } else {
//                 // didn't create one
//                 console.warn(`${lc} didn't create at this time.`);
//                 return undefined;
//             }
//         } catch (error) {
//             console.error(`${lc} error: ${extractErrorMsg(error)}`);
//             return undefined;
//         }
//     }
// }

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to mutate a comment ibgib. If the user chooses to save, then the modal will
 * perform the mutation, save the transform result in the given `space`, and
 * return the new comment ibgib.
 */
// export function getFn_promptUpdateCommentIbGib(
//     common: CommonService,
// ): (space: IbGibSpaceAny, commentIbGib: CommentIbGib_V1) => Promise<UpdateCommentPromptResult | undefined> {
//     const lc = `[${getFn_promptUpdateCommentIbGib.name}]`;
//     return async (space: IbGibSpaceAny, commentIbGib: CommentIbGib_V1) => {
//         try {
//             const modal = await common.modalController.create({
//                 component: UpdateCommentModalFormComponent,
//                 componentProps: { commentIbGib, space },
//             });
//             // have to register/clear modal for cancelling in case the user
//             // presses the back button while the modal is still visible
//             registerCancelModalOnBackButton(modal);
//             await modal.present();
//             let resModal = await modal.onWillDismiss();
//             // clear the cancel since it dismissed naturally
//             clearDoCancelModalOnBackButton();
//             if (resModal.data) {
//                 const resCreateComment = <UpdateCommentPromptResult>resModal.data;
//                 const addr = getIbGibAddr({ ibGib: resCreateComment.newIbGib });
//                 if (logalot) { console.log(`${lc} updated comment. addr: ${addr}`); }
//                 return resCreateComment;
//             } else {
//                 // didn't create one
//                 console.warn(`${lc} didn't create at this time.`);
//                 return undefined;
//             }
//         } catch (error) {
//             console.error(`${lc} error: ${extractErrorMsg(error)}`);
//             return undefined;
//         }
//     }
// }

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to create a robbot ibgib. If the user chooses to save, then the modal will
 * perform the mutation, save the transform result in the given `space`, and
 * return the new pic ibgib.
 */
// export function getFn_promptRobbotIbGib(
//     common: CommonService,
// ): (space: IbGibSpaceAny, ibGib: RobbotIbGib_V1) => Promise<RobbotPromptResult | undefined> {
//     const lc = `[${getFn_promptRobbotIbGib.name}]`;
//     return async (space: IbGibSpaceAny, ibGib: RobbotIbGib_V1) => {
//         try {
//             const modal = await common.modalController.create({
//                 component: RobbotModalFormComponent,
//                 componentProps: { ibGib, space },
//             });
//             // have to register/clear modal for cancelling in case the user
//             // presses the back button while the modal is still visible
//             registerCancelModalOnBackButton(modal);
//             await modal.present();
//             let resModal = await modal.onWillDismiss();
//             // clear the cancel since it dismissed naturally
//             clearDoCancelModalOnBackButton();
//             if (resModal.data) {
//                 const result = <RobbotPromptResult>resModal.data;
//                 return result;
//             } else {
//                 // didn't create one
//                 console.warn(`${lc} didn't create at this time.`);
//                 return undefined;
//             }
//         } catch (error) {
//             console.error(`${lc} error: ${extractErrorMsg(error)}`);
//             return undefined;
//         }
//     }
// }

/**
 * Creates a function with a single `space` arg. This fn when called shows a
 * modal to create a app ibgib. If the user chooses to save, then the modal will
 * perform the mutation, save the transform result in the given `space`, and
 * return the new pic ibgib.
 */
// export function getFn_promptAppIbGib(
//     common: CommonService,
// ): (space: IbGibSpaceAny, ibGib: AppIbGib_V1) => Promise<AppPromptResult | undefined> {
//     const lc = `[${getFn_promptAppIbGib.name}]`;
//     return async (space: IbGibSpaceAny, ibGib: AppIbGib_V1) => {
//         try {
//             const modal = await common.modalController.create({
//                 component: AppModalFormComponent,
//                 componentProps: { ibGib, space },
//             });
//             // have to register/clear modal for cancelling in case the user
//             // presses the back button while the modal is still visible
//             registerCancelModalOnBackButton(modal);
//             await modal.present();
//             let resModal = await modal.onWillDismiss();
//             // clear the cancel since it dismissed naturally
//             clearDoCancelModalOnBackButton();
//             if (resModal.data) {
//                 const result = <AppPromptResult>resModal.data;
//                 return result;
//             } else {
//                 // didn't create one
//                 console.warn(`${lc} didn't create at this time.`);
//                 return undefined;
//             }
//         } catch (error) {
//             console.error(`${lc} error: ${extractErrorMsg(error)}`);
//             return undefined;
//         }
//     }
// }