import apps from './apps.js';
import assert from 'node:assert';
import dashboard from './dashboard.js';
import logger from './logger.js';
import dns from './dns.js';
import eventlog from './eventlog.js';
import fs from 'node:fs';
import mailServer from './mailserver.js';
import network from './network.js';
import paths from './paths.js';
import safe from 'safetydance';
import tasks from './tasks.js';

const { log } = logger('dyndns');


// FIXME: this races with apptask. can result in a conflict if apptask is doing some dns operation and this code changes entries
async function refreshDns(auditSource) {
    assert.strictEqual(typeof auditSource, 'object');

    const ipv4 = await network.getIPv4();
    const ipv6 = await network.getIPv6();

    const info = safe.JSON.parse(safe.fs.readFileSync(paths.DYNDNS_INFO_FILE, 'utf8')) || { ipv4: null, ipv6: null };
    const ipv4Changed = info.ipv4 !== ipv4;
    const ipv6Changed = ipv6 && info.ipv6 !== ipv6; // both should be RFC 5952 format

    if (!ipv4Changed && !ipv6Changed) {
        log(`refreshDns: no change in IP. ipv4: ${ipv4} ipv6: ${ipv6}`);
        return;
    }

    log(`refreshDns: updating IP from ${info.ipv4} to ipv4: ${ipv4} (changed: ${ipv4Changed}) ipv6: ${ipv6} (changed: ${ipv6Changed})`);

    const taskId = await tasks.add(tasks.TASK_SYNC_DYNDNS, [ ipv4Changed ? ipv4 : null, ipv6Changed ? ipv6 : null, auditSource ]);
    // background
    tasks.startTask(taskId, {})
        .then(async () => {
            await eventlog.add(eventlog.ACTION_DYNDNS_UPDATE, auditSource, { taskId, fromIpv4: info.ipv4, fromIpv6: info.ipv6, toIpv4: ipv4, toIpv6: ipv6 });
            info.ipv4 = ipv4;
            info.ipv6 = ipv6;
            await fs.promises.writeFile(paths.DYNDNS_INFO_FILE, JSON.stringify(info), 'utf8');
        })
        .catch(async (error) => {
            await eventlog.add(eventlog.ACTION_DYNDNS_UPDATE, auditSource, { taskId, fromIpv4: info.ipv4, fromIpv6: info.ipv6, toIpv4: ipv4, toIpv6: ipv6, errorMessage: error.message });
        });

    return taskId;
}

async function sync(ipv4, ipv6, auditSource, progressCallback) {
    assert(ipv4 === null || typeof ipv4 === 'string');
    assert(ipv6 === null || typeof ipv6 === 'string');
    assert.strictEqual(typeof auditSource, 'object');
    assert.strictEqual(typeof progressCallback, 'function');

    let percent = 5;
    const { domain:dashboardDomain, fqdn:dashboardFqdn, subdomain:dashboardSubdomain } = await dashboard.getLocation();
    progressCallback({ percent, message: `Updating dashboard location ${dashboardFqdn}`});
    if (ipv4) await safe(dns.upsertDnsRecords(dashboardSubdomain, dashboardDomain, 'A', [ ipv4 ]), { debug: log });
    if (ipv6) await safe(dns.upsertDnsRecords(dashboardSubdomain, dashboardDomain, 'AAAA', [ ipv6 ]), { debug: log });

    const { domain:mailDomain, fqdn:mailFqdn, subdomain:mailSubdomain } = await mailServer.getLocation();
    percent += 10;
    progressCallback({ percent, message: `Updating mail location ${mailFqdn}`});
    if (dashboardFqdn !== mailFqdn) {
        if (ipv4) await safe(dns.upsertDnsRecords(mailSubdomain, mailDomain, 'A', [ ipv4 ]), { debug: log });
        if (ipv6) await safe(dns.upsertDnsRecords(mailSubdomain, mailDomain, 'AAAA', [ ipv6 ]), { debug: log });
    }

    const result = await apps.list();
    for (const app of result) {
        percent = Math.min(percent + Math.round(85 / result.length), 99);
        progressCallback({ percent, message: `Updating app ${app.fqdn}`});

        const locations = [{ domain: app.domain, subdomain: app.subdomain }]
            .concat(app.secondaryDomains)
            .concat(app.redirectDomains)
            .concat(app.aliasDomains);

        for (const location of locations) {
            if (ipv4) await safe(dns.upsertDnsRecords(location.subdomain, location.domain, 'A', [ ipv4 ]), { debug: log });
            if (ipv6) await safe(dns.upsertDnsRecords(location.subdomain, location.domain, 'AAAA', [ ipv6 ], { debug: log }));
        }
    }

    progressCallback({ percent: 100, message: 'Done' });
}

export default {
    refreshDns,
    sync
};
