const assert = require("assert");
const openpgp = require("openpgp");
const dayjs = require("dayjs");

const ut = { name: "Pagans" };

const apx = {};

apx.generateKey = async (alias, passphrase) => {
  try {
    console.log(`\nGenerating keys for alias: ${alias}`);
    const pgpParams = {
      type: "ecc",
      curve: "curve25519",
      userIDs: [{ name: alias }],
      passphrase: passphrase,
      format: "armored",
    };

    const key = await openpgp.generateKey(pgpParams);
    console.log(`Keys generated successfully for alias: ${alias}`);

    return {
      alias,
      passphrase,
      privatekey: key.privateKey,
      publickey: key.publicKey,
    };
  } catch (error) {
    console.error(`Error generating keys for alias: ${alias}`, error);
    return {};
  }
};

apx.createIdentity = async (alias, passphrase) => {
  try {
    const { privatekey, publickey } = await apx.generateKey(alias, passphrase);
    console.log(`Identity created successfully for alias: ${alias}`);
    return { alias, privatekey, publickey };
  } catch (error) {
    console.error(`Error creating identity for alias: ${alias}`, error);
  }
};

apx.joinTribe = async (alias, tribe) => {
  // Mock implementation of joining a tribe
  console.log(`Alias ${alias} joined tribe ${tribe}`);
  return true;
};

apx.deleteAlias = async (alias) => {
  // Mock implementation of deleting an alias
  console.log(`Alias ${alias} deleted`);
  return true;
};

const personData = {};

const apxFunctions = {
  modifyPersonData(alias, newFirstName) {
    if (!personData[alias]) {
      personData[alias] = {};
    }
    personData[alias].firstName = newFirstName;
    return personData[alias];
  },

  checkPersonData(alias, expectedFirstName) {
    return (
      personData[alias] && personData[alias].firstName === expectedFirstName
    );
  },

  removePersonModification(alias, originalFirstName) {
    if (personData[alias]) {
      personData[alias].firstName = originalFirstName;
    }
    return personData[alias];
  },

  deleteAlias(alias) {
    delete personData[alias];
    return !personData[alias];
  },
};

ut.test = {
  tribe: "smatchit",
  pagans: [
    {
      alias: "unittestadminsmatchit",
      passphrase: "adminsmatchitPass",
      persons: { firstname: "toto", lastname: "titi", profils: ["anonymous"] },
      testprofil: "adminrecruiter",
    },
    {
      alias: "unittestseeker",
      passphrase: "",
      persons: { firstname: "toto", lastname: "titi", profils: ["anonymous"] },
      testprofil: "seeker",
    },
  ],
};


ut.createpersons=()=>{
    let msg = "";
    ut.test.pagans.forEach((t) => {
        //test if alias does not already exist
        const pagan={}
        const getalias= Pagans.getalias(t.alias);
        if (getalias.status!=404) then alias already exist 
        else {delete}

        const keys = apx.generatekey(t.alias, t.passphrase)
        pagans.public key 


        schema.properties = t.properties;



      const res = Checkjson.schema.data(schema, t.data);
      if (res.status != t.status) {
        msg = msg == "" ? "Unconsistent testproperties() name list: " : `${msg},`;
        if (options.verbose) {
          console.log(t);
          console.log(res);
        }
        msg += res.err.map((e) => ` ${t.name} ${e.info}`);
      }
    });
    return assert.deepEqual(msg, "", msg);
}


Object.keys(pagans).forEach((key) => {
  pagans[key].headers = {
    xtrkversion: 1,
    xalias: "anonymous",
    xapp: "smatchapp",
    xdays: 0,
    xhash: "anonymous",
    xlang: "fr",
    xprofils: "anonymous",
    xtribe: "smatchit",
    xuuid: "0",
  };
});

const testCases = [
  {
    name: "Create Identity",
    async run(user) {
      const identity = await apx.createIdentity(user.alias, user.passphrase);
      if (identity) {
        user.privateKey = identity.privatekey;
        user.publicKey = identity.publickey;
      }
      return identity;
    },
    verify(identity, alias) {
      assert(identity, "Identity should not be undefined");
      assert(identity.alias === alias, "Alias should match");
      assert(
        identity.privatekey &&
          identity.privatekey.includes("BEGIN PGP PRIVATE KEY BLOCK"),
        "Private key is not valid"
      );
      assert(
        identity.publickey &&
          identity.publickey.includes("BEGIN PGP PUBLIC KEY BLOCK"),
        "Public key is not valid"
      );
    },
  },
  {
    name: "Join Tribe",
    async run(user) {
      return await apx.joinTribe(user.alias, "smatchit");
    },
    verify(result) {
      assert(result, "Joining tribe should return true");
    },
  },
  {
    name: "Delete Alias",
    async run(user) {
      return await apx.deleteAlias(user.alias);
    },
    verify(result) {
      assert(result, "Deleting alias should return true");
    },
  },
];

ut.run = async (options) => {
  console.log("Test Pagans Registration and Authentication");

  // Create and test identities for all users
  for (const userKey of Object.keys(pagans)) {
    const user = pagans[userKey];
    console.log(`\n--- Creating and testing identity for ${user.alias} ---`);

    for (const testCase of testCases) {
      console.log(`Running test case: ${testCase.name} for ${user.alias}`);
      try {
        const result = await testCase.run(user);
        if (result) {
          testCase.verify(result, user.alias);
          console.log(`Test case ${testCase.name} for ${user.alias} passed`);
        } else {
          console.error(
            `Test case ${testCase.name} for ${user.alias} failed: No result returned`
          );
        }
      } catch (error) {
        console.error(
          `Test case ${testCase.name} for ${user.alias} failed:`,
          error
        );
      }
    }

    console.log(`--- Finished testing for ${user.alias} ---\n`);
  }

  console.log("All test cases ran successfully");
};

module.exports = ut;

if (require.main === module) {
  ut.run({ verbose: true }).catch((err) => {
    console.error("Test case failed:", err);
  });
}