/**
 * Copyright (C) 2004-2011 Jive Software, 2023 Ignite Realtime Foundation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.jivesoftware.sparkimpl.updater;

import com.thoughtworks.xstream.XStream;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.ClassicHttpRequest;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.io.support.ClassicRequestBuilder;
import org.jivesoftware.Spark;
import org.jivesoftware.resource.Res;
import org.jivesoftware.resource.SparkRes;
import org.jivesoftware.smack.AbstractXMPPConnection;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.StanzaError;
import org.jivesoftware.smack.provider.ProviderManager;
import org.jivesoftware.smackx.disco.packet.DiscoverItems;
import org.jivesoftware.spark.SessionManager;
import org.jivesoftware.spark.SparkManager;
import org.jivesoftware.spark.component.ConfirmDialog;
import org.jivesoftware.spark.component.ConfirmDialog.ConfirmListener;
import org.jivesoftware.spark.component.TitlePanel;
import org.jivesoftware.spark.util.SwingWorker;
import org.jivesoftware.spark.util.*;
import org.jivesoftware.spark.util.log.Log;
import org.jivesoftware.sparkimpl.settings.JiveInfo;
import org.jivesoftware.sparkimpl.settings.local.LocalPreferences;
import org.jivesoftware.sparkimpl.settings.local.SettingsManager;
import org.jxmpp.jid.DomainBareJid;
import org.jxmpp.jid.Jid;
import org.jxmpp.jid.impl.JidCreate;

import javax.swing.*;
import javax.swing.text.html.HTMLEditorKit;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Timer;
import java.util.TimerTask;

public class CheckUpdates {
    public static final String UPDATER_SERVICE_SUBDOMAIN = "updater.";
    private final String mainUpdateURL;
    private JProgressBar bar;
    private TitlePanel titlePanel;
    private boolean downloadComplete = false;
    private boolean cancel = false;
    public static boolean UPDATING = false;
    private final boolean sparkPluginInstalled;
    private final XStream xstream = new XStream();
    private String sizeText;

    public CheckUpdates() {
        // Set the Jabber IQ Provider for Jabber:iq:spark
        ProviderManager.addIQProvider(SparkVersion.ELEMENT, SparkVersion.NAMESPACE, new SparkVersion.Provider());
        // For simplicity, use an alias for the root xml tag
        xstream.allowTypes(new Class[] {
            SparkVersion.class,
        });
        xstream.alias("Version", SparkVersion.class);
        xstream.registerConverter(new InstantConverter());
        // Specify the main update url for JiveSoftware
        this.mainUpdateURL = "http://www.igniterealtime.org/updater/updater";
        sparkPluginInstalled = isSparkPluginInstalled();
    }

    public SparkVersion newBuildAvailable() {
        SparkVersion serverVersion = null;
        if (sparkPluginInstalled) {
            serverVersion = getLatestVersion();
        }
        if (serverVersion == null && !Spark.disableUpdatesOnCustom()) {
            serverVersion = isNewBuildAvailableFromSite();
        }
        if (serverVersion == null) {
            return null;
        }
        return isGreater(serverVersion.getVersion(), JiveInfo.getVersion()) ? serverVersion : null;
    }

    /**
     * Returns a release version if there is a new build available for download.
     */
    public SparkVersion isNewBuildAvailableFromSite() {
        String os = currentOs();
        if (os == null) return null;

        //        Properties isBetaCheckingEnabled is now used to indicate if updates are allowed
        //        // Check to see if the beta should be included.
        //        LocalPreferences pref = SettingsManager.getLocalPreferences();
        //        boolean isBetaCheckingEnabled = pref.isBetaCheckingEnabled();
        //        if (isBetaCheckingEnabled) {
        //            post.addParameter("beta", "true");
        //        }
        try (final CloseableHttpClient httpClient =
                 HttpClients.custom().useSystemProperties()
                     .setConnectionManager(AcceptAllCertsConnectionManager.getInstance())
                     .build()
        ) {
            final ClassicHttpRequest request = ClassicRequestBuilder.post(mainUpdateURL)
                .addParameter("os", os)
                .setHeader("User-Agent", "Spark HttpFileUpload")
                .build();

            return httpClient.execute(request, httpResponse -> {
                if (httpResponse.getCode() == 200) {
                    String xml = EntityUtils.toString(httpResponse.getEntity());
                    // Server Version
                    SparkVersion serverVersion = (SparkVersion)xstream.fromXML(xml);
                    return serverVersion;
                }
                Log.warning("Bad status code for updates descriptor " + httpResponse.getCode());
                return null;
            });
        } catch (Exception e) {
            Log.error(e);
        }
        return null;
    }

    private static String currentOs() {
        if (Spark.isWindows()) {
            return "windows";
        } else if (Spark.isMac()) {
            return "mac";
        } else if (Spark.isLinux()) {
            return "linux";
        } else {
            return null;
        }
    }


    public void downloadUpdate(final File downloadedFile, final SparkVersion version) {
        Timer timer = new Timer();

        final HttpGet request = new HttpGet(version.getDownloadURL());
        try (final CloseableHttpClient httpClient =
                 HttpClients.custom().useSystemProperties()
                     .setConnectionManager(AcceptAllCertsConnectionManager.getInstance())
                     .build()
        ) {
            httpClient.execute(request, response -> {
                if (response.getCode() != 200) {
                    return null;
                }
                final HttpEntity entity = response.getEntity();
                int contentLength = (int) entity.getContentLength();
                bar = new JProgressBar(0, contentLength);
                final JFrame frame = new JFrame(Res.getString("title.downloading.im.client"));
                frame.setIconImage(SparkRes.getImageIcon(SparkRes.Icon.SMALL_MESSAGE_IMAGE).getImage());
                titlePanel = new TitlePanel(Res.getString("title.upgrading.client"), Res.getString("message.version", version.getVersion()), SparkRes.getImageIcon(SparkRes.Icon.SEND_FILE_24x24), true);
                final Thread thread = new Thread( () -> {
                    try {
                        InputStream stream = entity.getContent();
                        long size = entity.getContentLength();
                        ByteFormat formater = new ByteFormat();
                        sizeText = formater.format(size);
                        titlePanel.setDescription(Res.getString("message.version", version.getVersion()) + "\n" + Res.getString("message.file.size", sizeText));
                        //noinspection ResultOfMethodCallIgnored
                        downloadedFile.getParentFile().mkdirs();

                        FileOutputStream out = new FileOutputStream(downloadedFile);
                        copy(stream, out);
                        out.close();

                        if (!cancel) {
                            downloadComplete = true;
                            promptForInstallation(downloadedFile, Res.getString("title.download.complete"), Res.getString("message.restart.spark"));
                        }
                        else {
                            out.close();
                            //noinspection ResultOfMethodCallIgnored
                            downloadedFile.delete();
                        }
                        frame.dispose();
                    }
                    catch (Exception ex) {
                        // Nothing to do
                    }
                    finally {
                        UPDATING = false;
                        timer.cancel();
                    }
                } );

                frame.getContentPane().setLayout(new GridBagLayout());
                frame.getContentPane().add(titlePanel, new GridBagConstraints(0, 0, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(5, 5, 5, 5), 0, 0));
                frame.getContentPane().add(bar, new GridBagConstraints(0, 1, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(5, 5, 5, 5), 0, 0));

                JEditorPane pane = new JEditorPane();
                boolean displayContentPane = version.getChangeLogURL() != null || version.getDisplayMessage() != null;
                try {
                    pane.setEditable(false);
                    if (version.getChangeLogURL() != null) {
                        pane.setEditorKit(new HTMLEditorKit());
                        pane.setPage(version.getChangeLogURL());
                    }
                    else if (version.getDisplayMessage() != null) {
                        pane.setText(version.getDisplayMessage());
                    }
                    if (displayContentPane) {
                        frame.getContentPane().add(new JScrollPane(pane), new GridBagConstraints(0, 2, 1, 1, 1.0, 1.0, GridBagConstraints.WEST, GridBagConstraints.BOTH, new Insets(5, 5, 5, 5), 0, 0));
                    }
                }
                catch (IOException e) {
                    Log.error(e);
                }

                frame.getContentPane().setBackground(Color.WHITE);
                frame.pack();
                if (displayContentPane) {
                    frame.setSize(600, 400);
                }
                else {
                    frame.setSize(400, 100);
                }
                frame.setLocationRelativeTo(SparkManager.getMainWindow());
                GraphicUtils.centerWindowOnScreen(frame);
                frame.addWindowListener(new WindowAdapter() {
                    @Override
                    public void windowClosing(WindowEvent windowEvent) {
                        thread.interrupt();
                        cancel = true;
                        UPDATING = false;
                        if (!downloadComplete) {
                            JOptionPane.showMessageDialog(SparkManager.getMainWindow(), Res.getString("message.updating.cancelled"), Res.getString("title.cancelled"), JOptionPane.ERROR_MESSAGE);
                        }
                    }
                });
                frame.setVisible(true);
                thread.start();

                timer.scheduleAtFixedRate(new TimerTask() {
                    int seconds = 1;

                    @Override
                    public void run() {
                        ByteFormat formatter = new ByteFormat();
                        long value = bar.getValue();
                        long average = value / seconds;
                        String text = formatter.format(average) + "/Sec";
                        String total = formatter.format(value);
                        titlePanel.setDescription(Res.getString("message.version", version.getVersion()) + "\n" +
                            Res.getString("message.file.size", sizeText) + "\n" +
                            Res.getString("message.transfer.rate") + ": " + text + "\n" +
                            Res.getString("message.total.downloaded") + ": " + total);
                        seconds++;
                    }
                }, 1000, 1000);
                return null;
            });
        } catch (Exception e) {
            Log.error(e);
        }
    }

    /**
     * Common code for copy routines.  By convention, the streams are
     * closed in the same method in which they were opened.  Thus,
     * this method does not close the streams when the copying is done.
     *
     * @param in Source stream
     * @param out Destination stream
     */
    private void copy(final InputStream in, final OutputStream out) {
        int read = 0;
        try {
            final byte[] buffer = new byte[4096];
            while (!cancel) {
                int bytesRead = in.read(buffer);
                if (bytesRead < 0) {
                    break;
                }
                out.write(buffer, 0, bytesRead);
                read += bytesRead;
                bar.setValue(read);
            }
        }
        catch (IOException e) {
            Log.error(e);
        }
    }

    /**
     * Checks Spark Manager and/or Jive Software for the latest version of Spark.
     *
     * @param explicit true if the user explicitly asks for the latest version.
     */
    public void checkForUpdate(boolean explicit) {
        if (UPDATING) {
            return;
        }
        UPDATING = true;
        if (isLocalBuildAvailable()) {
            UPDATING = false;
            return;
        }
        LocalPreferences localPreferences = SettingsManager.getLocalPreferences();
        //defaults to 7, 0=disabled
        int CheckForUpdates = localPreferences.getCheckForUpdates();
        if (CheckForUpdates == 0) {
            UPDATING = false;
            return;
        }

        Instant lastChecked = localPreferences.getLastCheckForUpdates();
        if (lastChecked == null) {
            lastChecked = Instant.now();
            // This is the first invocation of Communicator
            localPreferences.setLastCheckForUpdates(lastChecked);
        }

        // Check to see if it has been a CheckForUpdates (default 7) days
        Instant lastCheckedPlusAPeriod = lastChecked.plus(CheckForUpdates, ChronoUnit.DAYS);
        boolean periodOrLonger = Instant.now().isAfter(lastCheckedPlusAPeriod);
        if (!periodOrLonger && !explicit && !sparkPluginInstalled) {
            UPDATING = false;
            return;
        }
        // beta versions downloaded only when explicitly checking for update
        if (!explicit && !localPreferences.isBetaCheckingEnabled())
        {
            UPDATING = false;
            return;
        }
            // Check version on server.
            localPreferences.setLastCheckForUpdates(Instant.now());
            final SparkVersion serverVersion = newBuildAvailable();
            if (serverVersion == null) {
                UPDATING = false;
                if (explicit) {
                    JOptionPane.showMessageDialog(SparkManager.getMainWindow(), Res.getString("message.no.updates"), Res.getString("title.no.updates"), JOptionPane.INFORMATION_MESSAGE);
                }
                return;
            }

            // Otherwise updates are available
            String downloadURL = serverVersion.getDownloadURL();
            String filename = downloadURL.substring(downloadURL.lastIndexOf("/") + 1);
            if (filename.indexOf('=') != -1) {
                filename = filename.substring(filename.indexOf('=') + 1);
            }
            // Set Download Directory
            final File downloadDir = new File(Spark.getSparkUserHome(), "updates");
            //noinspection ResultOfMethodCallIgnored
            downloadDir.mkdirs();
            // Set file to download.
            final File fileToDownload = new File(downloadDir, filename);
            if (fileToDownload.exists()) {
                //noinspection ResultOfMethodCallIgnored
                fileToDownload.delete();
            }

            ConfirmDialog confirm = new ConfirmDialog();
            confirm.showConfirmDialog(SparkManager.getMainWindow(), Res.getString("title.new.version.available"),
                    Res.getString("message.new.spark.available", filename), Res.getString("yes"), Res.getString("no"),
                    null);
            confirm.setDialogSize(400, 300);
            confirm.setConfirmListener(new ConfirmListener() {
                @Override
				public void yesOption() {
                    SwingWorker worker = new SwingWorker() {
                        @Override
						public Object construct() {
                            try {
                                Thread.sleep(50);
                            }
                            catch (InterruptedException e) {
                                Log.error(e);
                            }
                            return "ok";
                        }

                        @Override
						public void finished() {
                            if (Spark.isWindows() || Spark.isMac()) {
                                downloadUpdate(fileToDownload, serverVersion);
                            }
                            else {
                                // Launch browser to download page.
                                if (sparkPluginInstalled) {
                                    BrowserLauncher.openURL(serverVersion.getDownloadURL());
                                } else {
                                    BrowserLauncher.openURL("https://igniterealtime.org/downloads/index.jsp#spark");
                                }
                                UPDATING = false;
                            }
                        }
                    };
                    worker.start();
                }

                @Override
				public void noOption() {
                    UPDATING = false;
                }
            });
    }

    /**
     * Returns true if the first version number is greater than the second.
     *
     * @param firstVersion  the first version number.
     * @param secondVersion the second version number.
     * @return returns true if the first version is greater than the second.
     */
    public static boolean isGreater(String firstVersion, String secondVersion) {
        int indexOne = firstVersion.indexOf("_");
        if (indexOne != -1) {
            firstVersion = firstVersion.substring(indexOne + 1);
        }
        int indexTwo = secondVersion.indexOf("_");
        if (indexTwo != -1) {
            secondVersion = secondVersion.substring(indexTwo + 1);
        }
        firstVersion = firstVersion.replaceAll(".online", "");
        secondVersion = secondVersion.replace(".online", "");
        boolean versionOneBetaOrAlpha = firstVersion.toLowerCase().contains("beta") || firstVersion.toLowerCase().contains("alpha");
        boolean versionTwoBetaOrAlpha = secondVersion.toLowerCase().contains("beta") || secondVersion.toLowerCase().contains("alpha");
        // Handle case where they are both betas / alphas
        if ((versionOneBetaOrAlpha && versionTwoBetaOrAlpha) || (!versionOneBetaOrAlpha && !versionTwoBetaOrAlpha)) {
            return firstVersion.compareTo(secondVersion) >= 1;
        }
        // Handle the case where version 1 is a beta or alpha
        if (versionOneBetaOrAlpha) {
            String versionOne = getVersion(firstVersion);
            return versionOne.compareTo(secondVersion) >= 1;
        }
        else if (versionTwoBetaOrAlpha) {
            String versionTwo = getVersion(secondVersion);
            int result = firstVersion.compareTo(versionTwo);
            return result >= 0;
        }
        return firstVersion.compareTo(secondVersion) >= 1;
    }

    public static String getVersion(String version) {
        int lastIndexOf = version.lastIndexOf(".");
        if (lastIndexOf != -1) {
            return version.substring(0, lastIndexOf);
        }
        return version;
    }

    /**
     * Returns the latest version of Spark available via Spark Manager or website.
     *
     * @return the information for about the latest Spark Client or null.
     */
    public static SparkVersion getLatestVersion()
    {
        AbstractXMPPConnection connection = SparkManager.getConnection();
        SparkVersion request = new SparkVersion();
        request.setType(IQ.Type.get);
        request.setTo(JidCreate.fromOrThrowUnchecked(UPDATER_SERVICE_SUBDOMAIN + connection.getXMPPServiceDomain()));
        try {
            SparkVersion response = connection.sendIqRequestAndWaitForResponse(request);
            return response;
        } catch (XMPPException.XMPPErrorException e) {
            if (e.getStanzaError().getCondition() == StanzaError.Condition.item_not_found) {
                Log.debug("no new version available");
                return null;
            }
            Log.warning("Unable the check for new build.", e);
            return null;
        }  catch (Exception e) {
            Log.error("Unable the check for new build.", e);
            return null;
        }
    }

    /**
     * Does a service discovery on the server to see if a Client Control plugin is enabled.
     *
     * @return true if Spark Manager is available.
     */
    public static boolean isSparkPluginInstalled() {
        XMPPConnection con = SparkManager.getConnection();
        if (!con.isConnected()) {
            return false;
        }
        try {
            SessionManager sessionManager = SparkManager.getSessionManager();
            DomainBareJid serverDomain = sessionManager.getServerAddress();
            var items = sessionManager.getDiscoveredItems();
            Jid serviceJid = JidCreate.fromOrNull(UPDATER_SERVICE_SUBDOMAIN + serverDomain);
            DiscoverItems.Item item = items.get(serviceJid);
            if (item != null) {
                if ("Spark Updater".equals(item.getName())) {
                    return true;
                }
            }
        }
        catch (Exception e) {
            Log.error(e);
        }
        return false;
    }

    /**
     * Prompts the user to install the latest Spark.
     *
     * @param downloadedFile the location of the latest downloaded client.
     * @param title          the title
     * @param message        the message
     */
    private void promptForInstallation(final File downloadedFile, String title, String message) {
        ConfirmDialog confirm = new ConfirmDialog();
        confirm.showConfirmDialog(SparkManager.getMainWindow(), title,
                message, Res.getString("yes"), Res.getString("no"),
                null);
        confirm.setConfirmListener(new ConfirmListener() {
            @Override
			public void yesOption() {
                try {
                    if (Spark.isWindows()) {
                        Runtime.getRuntime().exec(downloadedFile.getAbsolutePath());
                    }
                    else if (Spark.isMac()) {
                        Runtime.getRuntime().exec("open " + downloadedFile.getCanonicalPath());
                    }
                }
                catch (IOException e) {
                    Log.error(e);
                }
                SparkManager.getMainWindow().shutdown();
            }

            @Override
			public void noOption() {

            }
        });
    }

    /**
     * Checks to see if a new version of Spark has already been downloaded by not installed.
     */
    private boolean isLocalBuildAvailable() {
        // Check the bin directory for previous downloads. If there is a
        // newer version of Spark, ask if they wish to install.
            File binDirectory = Spark.getBinDirectory();
            File[] files = binDirectory.listFiles(File::isFile);
            if (files == null) {
                return false;
            }
            for (File file : files) {
                String fileName = file.getName();
                if (Spark.isWindows() && fileName.endsWith(".exe") ||
                    Spark.isMac() && fileName.endsWith(".dmg")) {
                    if (isIsGreater(fileName)) {
                        // Prompt
                        promptForInstallation(file, Res.getString("title.new.client.available"), Res.getString("message.restart.spark.to.install"));
                        return true;
                    } else {
                        //noinspection ResultOfMethodCallIgnored
                        file.delete();
                    }
                }
            }
        return false;
    }

    private static boolean isIsGreater(String fileName) {
        int index = fileName.indexOf('_');
        // Add version number
        String versionNumber = fileName.substring(index + 1);
        int indexOfPeriod = versionNumber.indexOf('.');
        versionNumber = versionNumber.substring(0, indexOfPeriod);
        versionNumber = versionNumber.replace("_online", "");
        versionNumber = versionNumber.replace("_", ".");
        boolean isGreater = versionNumber.compareTo(JiveInfo.getVersion()) >= 1;
        return isGreater;
    }

}
