import { IOTAList, SignedTX, CommandType } from "./IOTAList";
import { RsaKeypair } from "../RsaKeypair";

export interface PermissionLevels {
    writingLevel : number,
    passWriteLevel : number,
    readingLevel : number,
    passReadLevel : number
}

export interface Permission extends SignedTX {
    permissionReceiverUUID : string,
    permissionLevels ?: PermissionLevels
}

export class PermissionList extends IOTAList{
    //List of all permissions, found through their UUID
    private Permissions : Permission[];

    constructor(address : string, provider : string) {
        super(address, provider);
        this.Permissions = [];
    }

    //Query PermissionList
    public QueryPermissionList(address : string = this.address) : Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            this.Permissions = [];
            this.GetTransactionsFromAddress(address)
            .then((msgs) => {
                //Loop through all the permission messages on the address
                for(let i=0; i < msgs.length; i++) {
                    //TODO: Verify that the tx actually follows the correct layout
                    msgs[i] = msgs[i].slice(0,msgs[i].lastIndexOf("}")+1);
                    let msg = JSON.parse(msgs[i]);
                    msg.permissionReceiverUUID = msg.permissionReceiverUUID.slice(msg.permissionReceiverUUID.lastIndexOf(":")+1);
                    //let permissionMessage : Permission = <Permission>JSON.parse(msgs[i]);
                    
                    //Follow the command
                    if(msg.commandType == CommandType.add) {
                        //Add or overwrite the permission
                        this.Permissions.push(msg);
                    } else if(msg.commandType == CommandType.retract) {
                        //Only remove a permission if it was there.
                        for(let i=0; i< this.Permissions.length;i++) {
                            if(this.Permissions[i].permissionReceiverUUID == msg.permissionReceiverUUID) {
                                this.Permissions.splice(i,1);
                                break;
                            }
                        }
                    }
                }
                resolve(true);
            })
            .catch((error) => {
                reject(error);
            })
        })
    }

    //TODO: Determine order and defaults
    public AddPermission(ReceiverUUID : string, permissionLevels : PermissionLevels, UUIDIssuer : string, publicKeyId : string, privateKey : string) : Promise<boolean> {
        return new Promise<boolean> ((resolve, reject) => {
            //TODO: Verify that you have the right to add a permission

            //TODO: Verify that you can give that permission level

            //TODO: Check private key - public key signature match

            //Sign the transaction
            let keypair : RsaKeypair = new RsaKeypair(undefined, privateKey);
            let currentTimeStamp = Date.now();
            let Signature = keypair.Sign(UUIDIssuer + publicKeyId + currentTimeStamp)

            //Create the Transactions
            let newPermission : Permission = {
                commandType : CommandType.add,
                permissionReceiverUUID : ReceiverUUID,
                permissionLevels : permissionLevels,
                signedByUUID : UUIDIssuer,
                publicKey : publicKeyId,
                time : currentTimeStamp,
                signature : Signature
            }

            //Put the TX on IOTA
            this.AddTransactionToAddress(JSON.stringify(newPermission))
            .then((isPosted) => {
                resolve(isPosted);
            })
            .catch((error) => {
                reject(error);
            });
        });
    }

    public RetractPermission(UUIDofRetracted : string, UUIDIssuer : string, publicKeyId : string, privateKey : string ) : Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            //TODO: Verify that the permission you want to retract is signed by you OR you have super/higher permissions

            //Sign the transaction
            let keypair : RsaKeypair = new RsaKeypair(undefined, privateKey);
            let currentTimeStamp = Date.now();
            let Signature = keypair.Sign(UUIDIssuer + publicKeyId + currentTimeStamp)

            //Create the Transactions
            let newPermission : Permission = {
                commandType : CommandType.retract,
                permissionReceiverUUID : UUIDofRetracted,
                signedByUUID : UUIDIssuer,
                publicKey : publicKeyId,
                time : currentTimeStamp,
                signature : Signature
            }

            //Put the TX on IOTA
            this.AddTransactionToAddress(JSON.stringify(newPermission))
            .then((isPosted) => {
                resolve(isPosted);
            })
            .catch((error) => {
                reject(error);
            });
        }); 
    }

    public GetPermissionStateOf( UUID : string) : Promise<PermissionLevels> {
        return new Promise<PermissionLevels> ((resolve, reject) => {
            //TODO: Verify the chain of permissions
            const EmptyPermissions : PermissionLevels = {writingLevel : 0, readingLevel : 0, passReadLevel : 0, passWriteLevel : 0};
            for(let i=0; i<this.Permissions.length; i++) {
                if(this.Permissions[i].permissionReceiverUUID == UUID) {
                    let Permission : Permission = this.Permissions[i];
                    this.ValidateSignature(Permission.signedByUUID, Permission.publicKey, Permission.time, Permission.signature)
                    .then((isVerified : boolean) => {
                        resolve(isVerified?Permission.permissionLevels:EmptyPermissions);
                    })
                    .catch((error) => {
                        reject(error);
                    });
                    return;
                }
            }
            //Return no permissions ;D
            resolve(EmptyPermissions);
        });
    }
}