import { createUserReturn, User, Process, createTransactionReturn, parse_network_msg, outputs_list, FaucetMessage, AnkFlag, NewTxMessage, encryptWithNewKeyResult, AnkSharedSecret, CachedMessage, UnknownMessage } from '../dist/pkg/sdk_client';
import IndexedDB from './database'
import { WebSocketClient } from './websockets';

class Services {
    private static instance: Services;
    private sdkClient: any;
    private current_process: string | null = null;
    private websocketConnection: WebSocketClient[] = [];
    private sp_address: string | null = null;

    // Private constructor to prevent direct instantiation from outside
    private constructor() {}

    // Method to access the singleton instance of Services
    public static async getInstance(): Promise<Services> {
        if (!Services.instance) {
            Services.instance = new Services();
            await Services.instance.init(); 
        }
        return Services.instance;
    }

    // The init method is now part of the instance, and should only be called once
    private async init(): Promise<void> {
        this.sdkClient = await import("../dist/pkg/sdk_client");
        this.sdkClient.setup();
        await this.updateProcesses();
    }

    public async addWebsocketConnection(url: string): Promise<void> {
        const services = await Services.getInstance();
        const newClient = new WebSocketClient(url, services);
        if (!services.websocketConnection.includes(newClient)) {
            services.websocketConnection.push(newClient);
        }
    }

    public async isNewUser(): Promise<boolean> { 
        let isNew = false;
        try {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            let userListObject = await indexedDB.getAll<User>(db, indexedDB.getStoreList().AnkUser);
            if (userListObject.length == 0) {
                isNew = true;
            }
        } catch (error) {
            console.error("Failed to retrieve isNewUser :", error);
        }               
        return isNew;
    }

    public async displayCreateId(): Promise<void> {
        const services = await Services.getInstance();
        await services.createIdInjectHtml();
        services.attachSubmitListener("form4nk", (event) => services.createId(event));
        services.attachClickListener("displayrecover", services.displayRecover);
        await services.displayProcess();
    }

    public async displaySendMessage(): Promise<void> {
        const services = await Services.getInstance();
        await services.injectHtml('Messaging');
        services.attachSubmitListener("form4nk", (event) => services.sendMessage(event));
        // const ourAddress = document.getElementById('our_address');
        // if (ourAddress) {
        //     ourAddress.innerHTML = `<strong>Our Address:</strong> ${this.sp_address}`
        // }
        // services.attachClickListener("displaysendmessage", services.displaySendMessage);
        // await services.displayProcess();
    }

    public async sendMessage(event: Event): Promise<void> {
        event.preventDefault();

        const services = await Services.getInstance();
        let availableAmt: number = 0;

        // check available amount
        try {
            availableAmt = await services.sdkClient.get_available_amount_for_user(true);
        } catch (error) {
            console.error('Failed to get available amount');
            return;
        }

        if (availableAmt < 2000) {
            try {
                await services.obtainTokenWithFaucet();
            } catch (error) {
                console.error('Failed to obtain faucet token:', error);
                return;
            }
        }

        const spAddressElement = document.getElementById("sp_address") as HTMLInputElement;
        const messageElement = document.getElementById("message") as HTMLInputElement;

        if (!spAddressElement || !messageElement) {
            console.error("One or more elements not found");
            return;
        }

        const recipientSpAddress = spAddressElement.value;
        const message = messageElement.value;

        const msg_payload: UnknownMessage = {sender: this.sp_address!, message: message};

        let notificationInfo = await services.notify_address_for_message(recipientSpAddress, msg_payload);
        if (notificationInfo) {
            let networkMsg = notificationInfo.new_network_msg;
            console.debug(networkMsg);

            const connection = await services.pickWebsocketConnectionRandom();
            const flag: AnkFlag = "Unknown";
            try {
                // send message (transaction in envelope)
                await services.updateMessages(networkMsg);
                connection?.sendMessage(flag, networkMsg.ciphertext!);
            } catch (error) {
                throw error;
            }
            // add peers list
            // add processes list
        }
    }

    public async createId(event: Event): Promise<void> {
        event.preventDefault(); 

        // verify we don't already have an user
        const services = await Services.getInstance();
        try {
            let user = await services.getUserInfo();
            if (user) {
                console.error("User already exists, please recover");
                return;
            }
        } catch (error) {
            throw error;
        }

        const passwordElement = document.getElementById("password") as HTMLInputElement;
        const processElement = document.getElementById("selectProcess") as HTMLSelectElement;

        if (!passwordElement || !processElement) {
            throw 'One or more elements not found';
        }

        const password = passwordElement.value;
        this.current_process = processElement.value;
        // console.log("JS password: " + password + " process: " + this.current_process);
        // To comment if test
        // if (!Services.instance.isPasswordValid(password)) return;

        const label = null;
        const birthday_signet = 50000;
        const birthday_main = 500000;

        let createUserReturn: createUserReturn;
        try {
            createUserReturn = services.sdkClient.create_user(password, label, birthday_main, birthday_signet, this.current_process);
        } catch (error) {
            throw error;
        }

        let user = createUserReturn.user;

        // const shares = user.shares;
        // send the shares on the network
        const revokeData = user.revoke_data;
        if (!revokeData) {
            throw 'Failed to get revoke data from wasm';
        }

        // user.shares = [];
        user.revoke_data = null;

        try {
            const indexedDb = await IndexedDB.getInstance();
            const db = await indexedDb.getDb();
            await indexedDb.writeObject(db, indexedDb.getStoreList().AnkUser, user, null);
        } catch (error) {
            throw `Failed to write user object: ${error}`;
        }

        try {
            await services.obtainTokenWithFaucet();
        } catch (error) {
            throw error;
        }

        await services.displayRevokeImage(new Uint8Array(revokeData));
    }

    public async displayRecover(): Promise<void> {
        const services = await Services.getInstance();
        await services.recoverInjectHtml();
        services.attachSubmitListener("form4nk", (event) => services.recover(event));
        services.attachClickListener("displaycreateid", services.displayCreateId);
        services.attachClickListener("displayrevoke", services.displayRevoke);
        services.attachClickListener("submitButtonRevoke", services.revoke);
        await services.displayProcess();
    }

    public async recover(event: Event) {
        event.preventDefault(); 

        const passwordElement = document.getElementById("password") as HTMLInputElement;
        const processElement = document.getElementById("selectProcess") as HTMLSelectElement;
        
        if (!passwordElement || !processElement) {
            console.error("One or more elements not found");
            return;
        }

        const password = passwordElement.value;
        const process = processElement.value;
        // console.log("JS password: " + password + " process: " + process);
        // To comment if test
        // if (!Services.instance.isPasswordValid(password)) return;

        // Get user in db
        const services = await Services.getInstance();
        try {
            const user = await services.getUserInfo();
            if (user) {
                services.sdkClient.login_user(password, user.pre_id, user.recover_data, user.shares, user.outputs);
                this.sp_address = services.sdkClient.get_recover_address();
                if (this.sp_address) {
                    console.info('Using sp_address:', this.sp_address);
                    await services.obtainTokenWithFaucet();
                }
            }
        } catch (error) {
            console.error(error);
        }

        console.info(this.sp_address);

        // TODO: check blocks since last_scan and update outputs

        await services.displaySendMessage();
    }

    public async displayRevokeImage(revokeData: Uint8Array): Promise<void> {
        const services = await Services.getInstance();
        await services.revokeImageInjectHtml();
        services.attachClickListener("displayupdateanid", services.displayUpdateAnId);

        let imageBytes = await services.getRecoverImage('assets/4nk_revoke.jpg');
        if (imageBytes != null) {
            var elem = document.getElementById("revoke") as HTMLAnchorElement;
            if (elem != null) {
                let imageWithData = services.sdkClient.add_data_to_image(imageBytes, revokeData, true);
                const blob = new Blob([imageWithData], { type: 'image/jpeg' });
                const url = URL.createObjectURL(blob);

                // Set the href attribute for download
                elem.href = url;
                elem.download = 'revoke_4NK.jpg';
            }
        }
    }

    private async getRecoverImage(imageUrl:string): Promise<Uint8Array|null> {
        let imageBytes = null;
        try {
            const response = await fetch(imageUrl);
            if (!response.ok) {
                throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
            }
            const arrayBuffer = await response.arrayBuffer();
            imageBytes = new Uint8Array(arrayBuffer);
        } catch (error) {
            console.error("Failed to get image : "+imageUrl, error);
        }
        return imageBytes;
    }

    public async displayRevoke(): Promise<void> {
        const services = await Services.getInstance();
        await services.revokeInjectHtml();
        services.attachClickListener("displayrecover", Services.instance.displayRecover);
        services.attachSubmitListener("form4nk", Services.instance.revoke);
    }

    public async revoke(event: Event): Promise<void> {
        event.preventDefault(); 
        console.log("JS revoke click ");
        // TODO
        alert("revoke click to do ...");
    }

    public async displayUpdateAnId() {
        const services = await Services.getInstance();

        await services.updateIdInjectHtml();

        services.attachSubmitListener("form4nk", services.updateAnId);
    }

    public async parseNetworkMessage(raw: string, feeRate: number): Promise<CachedMessage> {
        const services = await Services.getInstance();
        try {
            const msg: CachedMessage = services.sdkClient.parse_network_msg(raw, feeRate);
            return msg;
        } catch (error) {
            throw error;
        }
    }

    public async updateAnId(event: Event): Promise<void> {
        event.preventDefault(); 

        // TODO get values
        const firstNameElement = 'firstName';
        const lastNameElement = 'lastName';
        const firstName = document.getElementById(firstNameElement) as HTMLInputElement;
        const lastName = document.getElementById(lastNameElement) as HTMLInputElement;

        console.log("JS updateAnId submit ");
        // TODO
        alert("updateAnId submit to do ... Name : "+firstName.value + " "+lastName.value);

        // TODO Mock add user member to process
    }

    public async displayProcess(): Promise<void> {
        const services = await Services.getInstance();
        const processList = await services.getAllProcess();
        const selectProcess = document.getElementById("selectProcess");
        if (selectProcess) {
            processList.forEach((process) => {
                let child = new Option(process.name, process.name);
                if (!selectProcess.contains(child)) {
                    selectProcess.appendChild(child);
                }
            })
        }
    }

    public async addProcess(process: Process): Promise<void> {
        try {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            await indexedDB.writeObject(db, indexedDB.getStoreList().AnkProcess, process, null);
        } catch (error) {
            console.log('addProcess failed: ',error);
        }              
    }

    public async getAllProcess(): Promise<Process[]> {
        try {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            let processListObject = await indexedDB.getAll<Process>(db, indexedDB.getStoreList().AnkProcess);
            return processListObject;
        } catch (error) {
            console.log('getAllProcess failed: ',error);
            return [];
        }              
    }

    public async updateOwnedOutputsForUser(): Promise<void> {
        const services = await Services.getInstance();
        let latest_outputs: outputs_list;
        try {
            latest_outputs = services.sdkClient.get_outpoints_for_user();
        } catch (error) {
            console.error(error);
            return;
        }

        try {
            let user = await services.getUserInfo();
            if (user) {
                user.outputs = latest_outputs;
                // console.warn(user);
                await services.updateUser(user);
            }
        } catch (error) {
            console.error(error);
        }
    }
    
    public async getAllProcessForUser(pre_id: string): Promise<Process[]> { 
        const services = await Services.getInstance();
        let user: User;
        let userProcessList: Process[] = [];
        try {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            user = await indexedDB.getObject<User>(db, indexedDB.getStoreList().AnkUser, pre_id);
        } catch (error) {
            console.error('getAllUserProcess failed: ',error);
            return [];
        }

        try {
            const processListObject = await services.getAllProcess();
            processListObject.forEach(async (processObject) => {
                if (processObject.members.includes(user.pre_id)) {
                    userProcessList.push(processObject);
                }
            })
        } catch (error) {
            console.error('getAllUserProcess failed: ',error);
            return [];
        }              
        return userProcessList;
    }

    public async getProcessByName(name: string): Promise<Process | null> {
        console.log('getProcessByName name: '+name);
        const indexedDB = await IndexedDB.getInstance();
        const db = await indexedDB.getDb();
        const process = await indexedDB.getFirstMatchWithIndex<Process>(db, indexedDB.getStoreList().AnkProcess, 'by_name', name);
        console.log('getProcessByName process: '+process);

        return process;
    }

    public async updateMessages(message: CachedMessage): Promise<void> {
        const indexedDb = await IndexedDB.getInstance();
        const db = await indexedDb.getDb();

        try {
            await indexedDb.setObject(db, indexedDb.getStoreList().AnkMessages, message, null);
        } catch (error) {
            throw error;
        }
    }

    public async removeMessage(id: number): Promise<void> {
        const indexedDb = await IndexedDB.getInstance();
        const db = await indexedDb.getDb();

        try {
            await indexedDb.rmObject(db, indexedDb.getStoreList().AnkMessages, id);
        } catch (error) {
            throw error;
        }
    }

    public async updateProcesses(): Promise<void> { 
        const services = await Services.getInstance();
        const processList: Process[] = services.sdkClient.get_processes();

        processList.forEach(async (process: Process) => {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            try {
                const processStore = await indexedDB.getObject<Process>(db, indexedDB.getStoreList().AnkProcess, process.id);
                if (!processStore) {
                    await indexedDB.writeObject(db, indexedDB.getStoreList().AnkProcess, process, null);
                }
            } catch (error) {
                console.error('Error while writing process', process.name, 'to indexedDB:', error);
            }
        })
    }
    
    public attachClickListener(elementId: string, callback: (event: Event) => void): void {
        const element = document.getElementById(elementId);
        element?.removeEventListener("click", callback);
        element?.addEventListener("click", callback);
    }

    public attachSubmitListener(elementId: string, callback: (event: Event) => void): void {
        const element = document.getElementById(elementId);
        element?.removeEventListener("submit", callback);
        element?.addEventListener("submit", callback);
    }
    public async revokeInjectHtml() {
        const container = document.getElementById('containerId');

        if (!container) {
            console.error("No html container");
            return;
        }

        container.innerHTML = 
        ` <div class='card'>
            <div class='side-by-side'>
                <h3>Revoke an Id</h3>
                <div>
                    <a href='#' id='displayrecover'>Recover</a>
                </div>
            </div>
            <form id='form4nk' action='#'>
                <label for='password'>Password :</label>
                <input type='password' id='password' />
                <hr/>
                <div class='image-container'>
                    <label class='image-label'>Revoke image</label>
                    <img src='assets/revoke.jpeg' alt='' />
                </div>
                <hr/>
                <button type='submit' id='submitButton' class='recover bg-primary'>Revoke</button>
            </form>
        </div>
        `;
    }
    public async revokeImageInjectHtml() {
        const container = document.getElementById('containerId');

        if (!container) {
            console.error("No html container");
            return;
        }

        container.innerHTML = 
            `<div class='card'>
                <div class='side-by-side'>
                    <h3>Revoke image</h3>
                    <div><a href='#' id='displayupdateanid'>Update an Id</a></div>
                </div>
            </div>
            <div class='card-revoke'>
                <a href='#' download='revoke_4NK.jpg'  id='revoke'>
                        <svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 448 512'>
                        <path
                            d='M246.6 9.4c-12.5-12.5-32.8-12.5-45.3 0l-128 128c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L192 109.3V320c0 17.7 14.3 32 32 32s32-14.3 32-32V109.3l73.4 73.4c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3l-128-128zM64 352c0-17.7-14.3-32-32-32s-32 14.3-32 32v64c0 53 43 96 96 96H352c53 0 96-43 96-96V352c0-17.7-14.3-32-32-32s-32 14.3-32 32v64c0 17.7-14.3 32-32 32H96c-17.7 0-32-14.3-32-32V352z'
                        />
                        </svg>
                </a>
                <div class='image-container'>
                    <img src='assets/4nk_revoke.jpg' alt='' />
                </div>
            </div>`;
    }

    public async recoverInjectHtml() {
        const container = document.getElementById('containerId');

        if (!container) {
            console.error("No html container");
            return;
        }

        const services = await Services.getInstance();
        await services.updateProcesses();

        container.innerHTML = 
            `<div class='card'>
                <div class='side-by-side'>
                    <h3>Recover my Id</h3>
                    <div><a href='#'>Processes</a></div>
                </div>
                <form id='form4nk' action='#'>
                    <label for='password'>Password :</label>
                    <input type='password' id='password' />
                    <input type='hidden' id='currentpage' value='recover' />
                    <select id='selectProcess' class='custom-select'></select><hr/>
                    <div class='side-by-side'>
                        <button type='submit' id='submitButton' class='recover bg-primary'>Recover</button>
                        <div>
                            <a href='#' id='displaycreateid'>Create an Id</a>
                        </div>
                    </div><hr/>
                    <a href='#' id='displayrevoke' class='btn'>Revoke</a>
                </form><br/>
                <div id='passwordalert' class='passwordalert'></div>
            </div>`;
    }

    public async createIdInjectHtml() {
        const container = document.getElementById('containerId');

        if (!container) {
            console.error("No html container");
            return;
        }

        container.innerHTML = 
            `<div class='card'>
            <div class='side-by-side'>
                <h3>Create an Id</h3>
                <div><a href='#'>Processes</a></div>
            </div>
            <form id='form4nk' action='#'>
                <label for='password'>Password :</label>
                <input type='password' id='password' /><hr/>
                <input type='hidden' id='currentpage' value='creatid' />
                <select id='selectProcess' class='custom-select'></select><hr/>
                <div class='side-by-side'>
                    <button type='submit' id='submitButton' class='bg-primary'>Create</button>
                    <div>
                        <a href='#' id='displayrecover'>Recover</a>
                    </div>
                </div>
            </form><br/>
            <div id='passwordalert' class='passwordalert'></div>
            </div>`;
    }

    public async updateIdInjectHtml() {
        const container = document.getElementById('containerId');

        if (!container) {
            console.error("No html container");
            return;
        }

        container.innerHTML = 
            `<body>
                <div class='container'>
                <div>
                    <h3>Update an Id</h3>
                </div>
                <hr />
                <form id='form4nk' action='#'>
                    <label for='firstName'>First Name:</label>
                    <input type='text' id='firstName' name='firstName' required />

                    <label for='lastName'>Last Name:</label>
                    <input type='text' id='lastName' name='lastName' required />

                    <label for='Birthday'>Birthday:</label>
                    <input type='date' id='Birthday' name='birthday' />

                    <label for='file'>File:</label>
                    <input type='file' id='fileInput' name='file' />

                    <label>Third parties:</label>
                    <div id='sp-address-block'>
                    <div class='side-by-side'>
                        <input
                        type='text'
                        name='sp-address'
                        id='sp-address'
                        placeholder='sp address'
                        form='no-form'
                        />
                        <button
                        type='button'
                        class='circle-btn bg-secondary'
                        id='add-sp-address-btn'
                        >
                        +
                        </button>
                    </div>
                    </div>
                    <div class='div-text-area'>
                    <textarea
                        name='bio'
                        id=''
                        cols='30'
                        rows='10'
                        placeholder='Bio'
                    ></textarea>
                    </div>
                    <button type='submit' class='bg-primary'>Update</button>
                </form>
                </div>       
            </body>`;
    }

    public async injectHtml(processName: string) {
        const container = document.getElementById('containerId');

        if (!container) {
            console.error("No html container");
            return;
        }

        const services = await Services.getInstance();

        // do we have all processes in db?
        const knownProcesses = await services.getAllProcess();
        const processesFromNetwork: Process[] = services.sdkClient.get_processes();

        const processToAdd = processesFromNetwork.filter(processFromNetwork => !knownProcesses.some(knownProcess => knownProcess.id === processFromNetwork.id));

        processToAdd.forEach(async p => {
            await services.addProcess(p);
        })

        // get the process we need
        const process = await services.getProcessByName(processName);
        if (process) {
            container.innerHTML = process.html;
        } else {
            console.error("No process ", processName);
        }
    }

    // public async getCurrentProcess(): Promise<string> {
    //     let currentProcess = "";
    //     try {
    //         const indexedDB = await IndexedDB.getInstance();
    //         const db = indexedDB.getDb();
    //         currentProcess = await indexedDB.getObject<string>(db, indexedDB.getStoreList().AnkSession, Services.CURRENT_PROCESS);
    //     } catch (error) {
    //         console.error("Failed to retrieve currentprocess object :", error);
    //     }
    //     return currentProcess;
    // }
    
    public isPasswordValid(password: string) {
        var alertElem = document.getElementById("passwordalert");
        var success = true;
        var strength = 0;
        if (password.match(/[a-z]+/)) {
            var strength = 0;
            strength += 1;
        }
        if (password.match(/[A-Z]+/)) {
            strength += 1;
        }
        if (password.match(/[0-9]+/)) {
            strength += 1;
        }
        if (password.match(/[$@#&!]+/)) {
            strength += 1;
        }
        if (alertElem !== null) {
            // TODO Passer à 18
            if (password.length < 4) {
                alertElem.innerHTML = "Password size is < 4";
                success = false;
            } else {
                if (password.length > 30) {
                    alertElem.innerHTML = "Password size is > 30";
                    success = false;
                } else {
                    if (strength < 4) {
                        alertElem.innerHTML = "Password need [a-z] [A-Z] [0-9]+ [$@#&!]+";
                        success = false;
                    }
                }
            }
        }
        return success;
    }

    private async pickWebsocketConnectionRandom(): Promise<WebSocketClient | null> {
        const services = await Services.getInstance();
        const websockets = services.websocketConnection;
        if (websockets.length === 0) {
            console.error("No websocket connection available at the moment");
            return null;
        } else {
            const random = Math.floor(Math.random() * websockets.length);
            return websockets[random];
        }
    }

    public async obtainTokenWithFaucet(): Promise<void> {
        const services = await Services.getInstance();
        const connection = await services.pickWebsocketConnectionRandom();
        if (!connection) {
            throw 'no available relay connections';
        }

        let cachedMsg: CachedMessage;
        try {
            const flag: AnkFlag = 'Faucet';
            cachedMsg = services.sdkClient.create_faucet_msg();
            if (cachedMsg.commitment && cachedMsg.recipient) {
                let faucetMsg: FaucetMessage = {
                    sp_address: cachedMsg.recipient,
                    commitment: cachedMsg.commitment,
                }
                connection.sendMessage(flag, JSON.stringify(faucetMsg));
            }
        } catch (error) {
            throw `Failed to obtain tokens with relay ${connection.getUrl()}: ${error}`;
        }

        try {
            await services.updateMessages(cachedMsg);
        } catch (error) {
            throw error;
        }
    }

    public async updateUser(user: User): Promise<void> {
        try {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            await indexedDB.setObject(db, indexedDB.getStoreList().AnkUser, user, null);
        } catch (error) {
            throw error;
        }
    }

    public async getUserInfo(): Promise<User | null> {
        try {
            const indexedDB = await IndexedDB.getInstance();
            const db = await indexedDB.getDb();
            let user = await indexedDB.getAll<User>(db, indexedDB.getStoreList().AnkUser);
            // This should never happen
            if (user.length > 1) {
                throw "Multiple users in db";
            } else {
                let res = user.pop();
                if (res === undefined) {
                    return null;
                } else {
                    return res;
                }
            }
        } catch (error) {
            throw error;
        }
    }

    public async answer_confirmation_message(msg: CachedMessage): Promise<void> {
        const services = await Services.getInstance();
        const connection = await services.pickWebsocketConnectionRandom();
        if (!connection) {
            throw new Error("No connection to relay");
        }
        let user: User;
        try {
            let possibleUser = await services.getUserInfo();
            if (!possibleUser) {
                throw new Error("No user loaded, please first create a new user or login");
            } else {
                user = possibleUser;
            }
        } catch (error) {
            throw error;
        }

        let notificationInfo: createTransactionReturn;
        try {
            const feeRate = 1;
            notificationInfo = services.sdkClient.answer_confirmation_transaction(msg.id, feeRate);
        } catch (error) {
            throw new Error(`Failed to create confirmation transaction: ${error}`);
        }
        const flag: AnkFlag = "NewTx";
        const newTxMsg: NewTxMessage = {
            'transaction': notificationInfo.transaction,
            'tweak_data': null
        }
        connection.sendMessage(flag, JSON.stringify(newTxMsg));
        await services.updateMessages(notificationInfo.new_network_msg);
        return;
    }

    public async confirm_sender_address(msg: CachedMessage): Promise<void> {
        const services = await Services.getInstance();
        const connection = await services.pickWebsocketConnectionRandom();
        if (!connection) {
            throw new Error("No connection to relay");
        }
        let user: User;
        try {
            let possibleUser = await services.getUserInfo();
            if (!possibleUser) {
                throw new Error("No user loaded, please first create a new user or login");
            } else {
                user = possibleUser;
            }
        } catch (error) {
            throw error;
        }

        let notificationInfo: createTransactionReturn;
        try {
            const feeRate = 1;
            notificationInfo = services.sdkClient.create_confirmation_transaction(msg.id, feeRate);
        } catch (error) {
            throw new Error(`Failed to create confirmation transaction: ${error}`);
        }
        const flag: AnkFlag = "NewTx";
        const newTxMsg: NewTxMessage = {
            'transaction': notificationInfo.transaction,
            'tweak_data': null
        }
        connection.sendMessage(flag, JSON.stringify(newTxMsg));
        await services.updateMessages(notificationInfo.new_network_msg);
        return;
    }

    public async notify_address_for_message(sp_address: string, message: UnknownMessage): Promise<createTransactionReturn> {
        const services = await Services.getInstance();
        const connection = await services.pickWebsocketConnectionRandom();
        if (!connection) {
            throw 'No available connection';
        }

        try {
            const feeRate = 1;
            let notificationInfo: createTransactionReturn = services.sdkClient.create_notification_transaction(sp_address, message, feeRate);
            const flag: AnkFlag = "NewTx";
            const newTxMsg: NewTxMessage = {
                'transaction': notificationInfo.transaction,
                'tweak_data': null
            }
            connection.sendMessage(flag, JSON.stringify(newTxMsg));
            console.info('Successfully sent notification transaction');
            return notificationInfo;
        } catch (error) {
            throw 'Failed to create notification transaction:", error';
        }
    }
}

export default Services;