using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Net;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Web.Script.Serialization;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace GesisOpenCodeInstaller
{
    internal static class Program
    {
        [STAThread]
        private static void Main()
        {
            TryEnableDpiAwareness();
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new InstallerForm());
        }

        [DllImport("user32.dll")]
        private static extern bool SetProcessDPIAware();

        private static void TryEnableDpiAwareness()
        {
            try
            {
                SetProcessDPIAware();
            }
            catch
            {
            }
        }
    }

    internal sealed class InstallerForm : Form
    {
        private const string Repo = "anomalyco/opencode";
        private const string ReleaseApiUrl = "https://api.github.com/repos/" + Repo + "/releases/latest";
        private const string WindowsAssetName = "opencode-desktop-win-x64.exe";
        private const string BaseUrl = "https://ai-openwebui.gesis.org/api";
        private const int DesktopInstallerWaitMilliseconds = 15000;
        private const int DownloadTimeoutMilliseconds = 60000;

        private readonly TextBox apiKeyBox;
        private readonly TextBox modelFilterBox;
        private readonly TableLayoutPanel modelGridPanel;
        private readonly Label modelIntroLabel;
        private readonly Button checkApiKeyButton;
        private readonly Button backButton;
        private readonly Button installButton;
        private readonly Button selectAllButton;
        private readonly Button selectNoneButton;
        private readonly ProgressBar progressBar;
        private readonly Label statusLabel;
        private readonly CheckBox skipDesktopCheckBox;
        private readonly List<ModelOption> availableModels = new List<ModelOption>();

        public InstallerForm()
        {
            Text = "GESIS OpenCode Installer";
            StartPosition = FormStartPosition.CenterScreen;
            FormBorderStyle = FormBorderStyle.Sizable;
            MaximizeBox = true;
            MinimizeBox = true;
            ClientSize = new Size(760, 560);
            MinimumSize = new Size(620, 500);
            Font = new Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point);
            BackColor = Color.White;
            AutoScaleMode = AutoScaleMode.Dpi;
            AutoScroll = false;

            var logoBox = new PictureBox
            {
                Margin = new Padding(0, 0, 0, 18),
                Size = new Size(330, 92),
                SizeMode = PictureBoxSizeMode.Zoom,
                Image = LoadEmbeddedImage("GesisLogo")
            };

            var title = new Label
            {
                Text = "Install OpenCode Desktop for GESIS",
                Font = new Font(Font.FontFamily, 15F, FontStyle.Bold),
                AutoSize = true,
                MaximumSize = new Size(680, 0),
                Margin = new Padding(0, 0, 0, 8)
            };

            var description = new Label
            {
                Text = "This installer checks your personal API key, lets you choose the GESIS AI Server models to show in OpenCode, and downloads the latest OpenCode Desktop for Windows.",
                AutoSize = true,
                MaximumSize = new Size(680, 0),
                Margin = new Padding(0, 0, 0, 22)
            };

            var apiKeyLabel = new Label
            {
                Text = "Personal GESIS API key",
                AutoSize = true,
                Margin = new Padding(0, 0, 0, 6)
            };

            apiKeyBox = new TextBox
            {
                Dock = DockStyle.Fill,
                Margin = new Padding(0, 0, 0, 14),
                MinimumSize = new Size(420, 30),
                UseSystemPasswordChar = true
            };

            checkApiKeyButton = new Button
            {
                Text = "Check API key",
                AutoSize = true,
                MinimumSize = new Size(150, 40),
                Padding = new Padding(12, 4, 12, 4),
                Margin = new Padding(0, 0, 0, 18)
            };
            checkApiKeyButton.Click += CheckApiKeyButton_Click;

            modelIntroLabel = new Label
            {
                Text = "These are all models currently available to your API key on the GESIS AI Server. Select the models you want to use in OpenCode.",
                AutoSize = true,
                MaximumSize = new Size(680, 0),
                Margin = new Padding(0, 0, 0, 10),
                Visible = false
            };

            modelFilterBox = new TextBox
            {
                Dock = DockStyle.Fill,
                Margin = new Padding(0, 0, 0, 10),
                MinimumSize = new Size(420, 30),
                Visible = false
            };
            modelFilterBox.TextChanged += ModelFilterBox_TextChanged;

            modelGridPanel = new TableLayoutPanel
            {
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                BackColor = Color.White,
                ColumnCount = 1,
                Dock = DockStyle.Fill,
                Margin = new Padding(0, 0, 0, 10),
                Visible = false
            };

            selectAllButton = new Button
            {
                Text = "Select all",
                AutoSize = true,
                MinimumSize = new Size(110, 36),
                Padding = new Padding(10, 3, 10, 3),
                Visible = false
            };
            selectAllButton.Click += SelectAllButton_Click;

            selectNoneButton = new Button
            {
                Text = "Select none",
                AutoSize = true,
                MinimumSize = new Size(110, 36),
                Padding = new Padding(10, 3, 10, 3),
                Visible = false
            };
            selectNoneButton.Click += SelectNoneButton_Click;

            skipDesktopCheckBox = new CheckBox
            {
                Text = "Only update the OpenCode configuration",
                AutoSize = true,
                Margin = new Padding(0, 0, 0, 18),
                Visible = false
            };

            installButton = new Button
            {
                Text = "Install selected models",
                AutoSize = true,
                MinimumSize = new Size(190, 40),
                Padding = new Padding(12, 4, 12, 4),
                Anchor = AnchorStyles.Right,
                Margin = new Padding(8, 0, 0, 18),
                Visible = false
            };
            installButton.Click += InstallButton_Click;

            backButton = new Button
            {
                Text = "Back",
                AutoSize = true,
                MinimumSize = new Size(100, 40),
                Padding = new Padding(12, 4, 12, 4),
                Margin = new Padding(8, 0, 0, 18),
                Visible = false
            };
            backButton.Click += BackButton_Click;

            progressBar = new ProgressBar
            {
                Dock = DockStyle.Fill,
                MinimumSize = new Size(420, 18),
                Margin = new Padding(0, 0, 0, 12),
                Style = ProgressBarStyle.Continuous
            };

            statusLabel = new Label
            {
                Text = "Ready.",
                AutoSize = true,
                MaximumSize = new Size(680, 0),
                Margin = new Padding(0)
            };

            var icon = LoadEmbeddedIcon("GesisIcon");
            if (icon != null)
            {
                Icon = icon;
            }

            var selectionButtonPanel = new FlowLayoutPanel
            {
                Dock = DockStyle.Fill,
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                FlowDirection = FlowDirection.LeftToRight,
                WrapContents = true,
                Margin = new Padding(0, 0, 0, 12)
            };
            selectionButtonPanel.Controls.Add(selectAllButton);
            selectionButtonPanel.Controls.Add(selectNoneButton);

            var primaryButtonPanel = new FlowLayoutPanel
            {
                Dock = DockStyle.Fill,
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                FlowDirection = FlowDirection.RightToLeft,
                WrapContents = true
            };
            primaryButtonPanel.Controls.Add(installButton);
            primaryButtonPanel.Controls.Add(backButton);
            primaryButtonPanel.Controls.Add(checkApiKeyButton);

            var footerLayout = new TableLayoutPanel
            {
                Dock = DockStyle.Fill,
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                BackColor = Color.White,
                ColumnCount = 1,
                RowCount = 4,
                Padding = new Padding(32, 12, 32, 16)
            };
            footerLayout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
            footerLayout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            footerLayout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            footerLayout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            footerLayout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            footerLayout.Controls.Add(skipDesktopCheckBox, 0, 0);
            footerLayout.Controls.Add(primaryButtonPanel, 0, 1);
            footerLayout.Controls.Add(progressBar, 0, 2);
            footerLayout.Controls.Add(statusLabel, 0, 3);

            var layout = new TableLayoutPanel
            {
                Dock = DockStyle.Top,
                AutoSize = true,
                AutoSizeMode = AutoSizeMode.GrowAndShrink,
                BackColor = Color.White,
                ColumnCount = 1,
                Padding = new Padding(32),
                RowCount = 10
            };
            layout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
            for (var i = 0; i < layout.RowCount; i++)
            {
                layout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            }

            layout.Controls.Add(logoBox, 0, 0);
            layout.Controls.Add(title, 0, 1);
            layout.Controls.Add(description, 0, 2);
            layout.Controls.Add(apiKeyLabel, 0, 3);
            layout.Controls.Add(apiKeyBox, 0, 4);
            layout.Controls.Add(modelIntroLabel, 0, 5);
            layout.Controls.Add(modelFilterBox, 0, 6);
            layout.Controls.Add(selectionButtonPanel, 0, 7);
            layout.Controls.Add(modelGridPanel, 0, 8);

            var contentPanel = new Panel
            {
                Dock = DockStyle.Fill,
                AutoScroll = true,
                BackColor = Color.White
            };
            contentPanel.Controls.Add(layout);

            var rootLayout = new TableLayoutPanel
            {
                Dock = DockStyle.Fill,
                BackColor = Color.White,
                ColumnCount = 1,
                RowCount = 2
            };
            rootLayout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F));
            rootLayout.RowStyles.Add(new RowStyle(SizeType.Percent, 100F));
            rootLayout.RowStyles.Add(new RowStyle(SizeType.AutoSize));
            rootLayout.Controls.Add(contentPanel, 0, 0);
            rootLayout.Controls.Add(footerLayout, 0, 1);

            Controls.Add(rootLayout);

            AcceptButton = checkApiKeyButton;
        }

        protected override void OnShown(EventArgs e)
        {
            base.OnShown(e);
            if (WindowState == FormWindowState.Minimized)
            {
                WindowState = FormWindowState.Normal;
            }

            Show();
            Activate();
            BringToFront();
            TopMost = true;
            TopMost = false;
        }

        private static Image LoadEmbeddedImage(string resourceName)
        {
            var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
            if (stream == null)
            {
                return null;
            }

            using (stream)
            {
                return Image.FromStream(stream);
            }
        }

        private static Icon LoadEmbeddedIcon(string resourceName)
        {
            var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
            if (stream == null)
            {
                return null;
            }

            return new Icon(stream);
        }

        private async void CheckApiKeyButton_Click(object sender, EventArgs e)
        {
            var apiKey = apiKeyBox.Text.Trim();
            if (apiKey.Length == 0)
            {
                MessageBox.Show(this, "Please enter your personal GESIS API key.", "API key required", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                apiKeyBox.Focus();
                return;
            }

            SetBusy(true);

            try
            {
                var models = await Task.Run(new Func<List<ModelOption>>(() => ProbeAvailableModels(apiKey)));
                if (models.Count == 0)
                {
                    throw new InvalidOperationException("No models are available for this API key.");
                }

                availableModels.Clear();
                availableModels.AddRange(models);
                foreach (var model in availableModels)
                {
                    model.IsSelected = true;
                }

                WindowState = FormWindowState.Maximized;
                ShowModelSelection();
                RefreshModelList();
                ResizeForModelGrid();
                progressBar.Value = 100;
                statusLabel.Text = "Found " + availableModels.Count + " available model(s). Choose which models should appear in OpenCode.";
            }
            catch (Exception ex)
            {
                statusLabel.Text = "API key check failed.";
                MessageBox.Show(this, ex.Message, "API key check failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                SetBusy(false);
            }
        }

        private async void InstallButton_Click(object sender, EventArgs e)
        {
            var apiKey = apiKeyBox.Text.Trim();
            var selectedModels = GetSelectedModels();

            if (selectedModels.Count == 0)
            {
                MessageBox.Show(this, "Please select at least one model to use in OpenCode.", "Model selection required", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            SetBusy(true);

            try
            {
                await Task.Run(new Action(() => WriteOpenCodeConfig(apiKey, selectedModels)));

                if (!skipDesktopCheckBox.Checked)
                {
                    await Task.Run(new Action(InstallOpenCodeDesktop));
                }

                progressBar.Value = 100;
                statusLabel.Text = "Installation complete.";
                MessageBox.Show(this, "OpenCode is configured for the GESIS AI Server. If the OpenCode Desktop installer is still open, please follow its prompts to finish.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                statusLabel.Text = "Installation failed.";
                MessageBox.Show(this, ex.Message, "Installation failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            finally
            {
                SetBusy(false);
            }
        }

        private void BackButton_Click(object sender, EventArgs e)
        {
            ShowApiKeyScreen();
        }

        private void ModelFilterBox_TextChanged(object sender, EventArgs e)
        {
            SyncVisibleModelSelection();
            RefreshModelList();
        }

        private void SelectAllButton_Click(object sender, EventArgs e)
        {
            SetVisibleModelSelection(true);
        }

        private void SelectNoneButton_Click(object sender, EventArgs e)
        {
            SetVisibleModelSelection(false);
        }

        private void ShowModelSelection()
        {
            checkApiKeyButton.Visible = false;
            apiKeyBox.Enabled = false;
            modelIntroLabel.Visible = true;
            modelFilterBox.Visible = true;
            modelGridPanel.Visible = true;
            selectAllButton.Visible = true;
            selectNoneButton.Visible = true;
            skipDesktopCheckBox.Visible = true;
            installButton.Visible = true;
            backButton.Visible = true;
            AcceptButton = installButton;
        }

        private void ShowApiKeyScreen()
        {
            WindowState = FormWindowState.Normal;
            checkApiKeyButton.Visible = true;
            apiKeyBox.Enabled = true;
            modelIntroLabel.Visible = false;
            modelFilterBox.Visible = false;
            modelGridPanel.Visible = false;
            selectAllButton.Visible = false;
            selectNoneButton.Visible = false;
            skipDesktopCheckBox.Visible = false;
            installButton.Visible = false;
            backButton.Visible = false;
            progressBar.Value = 0;
            statusLabel.Text = "Ready.";
            AcceptButton = checkApiKeyButton;
        }

        private void InstallOpenCodeDesktop()
        {
            if (!Environment.Is64BitOperatingSystem)
            {
                throw new InvalidOperationException("This installer requires 64-bit Windows.");
            }

            SetStatus("Finding the latest OpenCode Desktop release...", 10);
            var releaseJson = DownloadString(ReleaseApiUrl);
            var serializer = new JavaScriptSerializer();
            var release = (Dictionary<string, object>)serializer.DeserializeObject(releaseJson);
            var tagName = release.ContainsKey("tag_name") ? Convert.ToString(release["tag_name"]) : "latest";
            var assets = release["assets"] as object[];
            Dictionary<string, object> selectedAsset = null;

            if (assets != null)
            {
                foreach (var item in assets)
                {
                    var asset = item as Dictionary<string, object>;
                    if (asset == null || !asset.ContainsKey("name"))
                    {
                        continue;
                    }

                    if (String.Equals(Convert.ToString(asset["name"]), WindowsAssetName, StringComparison.OrdinalIgnoreCase))
                    {
                        selectedAsset = asset;
                        break;
                    }
                }
            }

            if (selectedAsset == null || !selectedAsset.ContainsKey("browser_download_url"))
            {
                throw new InvalidOperationException("Could not find the Windows desktop installer in the latest OpenCode release.");
            }

            var downloadUrl = Convert.ToString(selectedAsset["browser_download_url"]);
            var downloadPath = Path.Combine(Path.GetTempPath(), WindowsAssetName);
            var expectedSize = selectedAsset.ContainsKey("size") ? Convert.ToInt64(selectedAsset["size"]) : -1;

            if (expectedSize > 0 && File.Exists(downloadPath) && new FileInfo(downloadPath).Length == expectedSize)
            {
                SetStatus("Using already downloaded OpenCode Desktop " + tagName + ".", 70);
            }
            else
            {
                SetStatus("Downloading OpenCode Desktop " + tagName + "...", 30);
                DownloadFileWithProgress(downloadUrl, downloadPath, expectedSize, "OpenCode Desktop " + tagName, 30, 70);
            }

            SetStatus("Starting the OpenCode Desktop installer...", 75);
            var process = Process.Start(new ProcessStartInfo
            {
                FileName = downloadPath,
                UseShellExecute = true
            });

            if (process == null)
            {
                throw new InvalidOperationException("Could not start the OpenCode Desktop installer.");
            }

            SetStatus("Waiting briefly for the OpenCode Desktop installer...", 90);
            if (process.WaitForExit(DesktopInstallerWaitMilliseconds))
            {
                if (process.ExitCode != 0)
                {
                    throw new InvalidOperationException("The OpenCode Desktop installer ended with exit code " + process.ExitCode + ".");
                }

                return;
            }

            SetStatus("OpenCode Desktop installer is still running. Continuing with GESIS setup.", 95);
        }

        private void DownloadFileWithProgress(string url, string destinationPath, long expectedSize, string label, int startProgress, int endProgress)
        {
            var partialPath = destinationPath + ".download";
            if (File.Exists(partialPath))
            {
                File.Delete(partialPath);
            }

            var request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "GET";
            request.Timeout = DownloadTimeoutMilliseconds;
            request.ReadWriteTimeout = DownloadTimeoutMilliseconds;
            request.UserAgent = "GESIS-OpenCode-Installer";
            request.Accept = "application/octet-stream";

            using (var response = (HttpWebResponse)request.GetResponse())
            {
                if (response.StatusCode != HttpStatusCode.OK)
                {
                    throw new InvalidOperationException("Could not download OpenCode Desktop. The server returned " + response.StatusCode + ".");
                }

                var totalBytes = response.ContentLength > 0 ? response.ContentLength : expectedSize;
                var downloadedBytes = 0L;
                var buffer = new byte[1024 * 128];
                var lastUpdate = DateTime.MinValue;

                using (var input = response.GetResponseStream())
                using (var output = File.Create(partialPath))
                {
                    if (input == null)
                    {
                        throw new InvalidOperationException("Could not download OpenCode Desktop. The server returned no file content.");
                    }

                    while (true)
                    {
                        var read = input.Read(buffer, 0, buffer.Length);
                        if (read <= 0)
                        {
                            break;
                        }

                        output.Write(buffer, 0, read);
                        downloadedBytes += read;

                        if ((DateTime.Now - lastUpdate).TotalMilliseconds >= 250)
                        {
                            lastUpdate = DateTime.Now;
                            UpdateDownloadStatus(label, downloadedBytes, totalBytes, startProgress, endProgress);
                        }
                    }
                }

                if (expectedSize > 0 && downloadedBytes != expectedSize)
                {
                    throw new InvalidOperationException("The OpenCode Desktop download was incomplete. Please check your internet connection and try again.");
                }

                if (File.Exists(destinationPath))
                {
                    File.Delete(destinationPath);
                }

                File.Move(partialPath, destinationPath);
                UpdateDownloadStatus(label, downloadedBytes, totalBytes, startProgress, endProgress);
            }
        }

        private void UpdateDownloadStatus(string label, long downloadedBytes, long totalBytes, int startProgress, int endProgress)
        {
            var downloadedMb = downloadedBytes / 1024.0 / 1024.0;

            if (totalBytes > 0)
            {
                var totalMb = totalBytes / 1024.0 / 1024.0;
                var ratio = Math.Max(0, Math.Min(1, downloadedBytes / (double)totalBytes));
                var progress = startProgress + (int)((endProgress - startProgress) * ratio);
                SetStatus("Downloading " + label + "... " + downloadedMb.ToString("0.0") + " MB of " + totalMb.ToString("0.0") + " MB", progress);
                return;
            }

            SetStatus("Downloading " + label + "... " + downloadedMb.ToString("0.0") + " MB", startProgress);
        }

        private void WriteOpenCodeConfig(string apiKey, List<ModelOption> selectedModels)
        {
            SetStatus("Writing OpenCode configuration...", 85);

            var userProfile = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
            var configDirectory = Path.Combine(userProfile, ".config", "opencode");
            var configPath = Path.Combine(configDirectory, "opencode.json");

            Directory.CreateDirectory(configDirectory);

            if (File.Exists(configPath))
            {
                var backupPath = configPath + ".backup-" + DateTime.Now.ToString("yyyyMMdd-HHmmss");
                File.Copy(configPath, backupPath, true);
            }

            File.WriteAllText(configPath, BuildConfigJson(apiKey, selectedModels), new UTF8Encoding(false));
        }

        private static string BuildConfigJson(string apiKey, List<ModelOption> selectedModels)
        {
            var modelsJson = new StringBuilder();
            for (var i = 0; i < selectedModels.Count; i++)
            {
                var model = selectedModels[i];
                modelsJson.Append("        \"");
                modelsJson.Append(JsonEscape(model.Id));
                modelsJson.Append("\": { \"name\": \"");
                modelsJson.Append(JsonEscape(model.Name));
                modelsJson.Append("\" }");
                if (i < selectedModels.Count - 1)
                {
                    modelsJson.Append(",");
                }

                modelsJson.Append("\n");
            }

            return "{\n" +
                "  \"$schema\": \"https://opencode.ai/config.json\",\n" +
                "  \"enabled_providers\": [\"gesis\"],\n" +
                "  \"disabled_providers\": [\"zen\", \"opencode\"],\n" +
                "  \"provider\": {\n" +
                "    \"gesis\": {\n" +
                "      \"npm\": \"@ai-sdk/openai-compatible\",\n" +
                "      \"name\": \"GESIS AI Server\",\n" +
                "      \"options\": {\n" +
                "        \"baseURL\": \"" + JsonEscape(BaseUrl) + "\",\n" +
                "        \"apiKey\": \"" + JsonEscape(apiKey) + "\"\n" +
                "      },\n" +
                "      \"models\": {\n" +
                modelsJson +
                "      }\n" +
                "    }\n" +
                "  }\n" +
                "}\n";
        }

        private List<ModelOption> ProbeAvailableModels(string apiKey)
        {
            var endpoints = new[]
            {
                BaseUrl.TrimEnd('/') + "/models",
                BaseUrl.TrimEnd('/') + "/v1/models"
            };

            Exception lastError = null;
            var sawEmptyModelList = false;
            foreach (var endpoint in endpoints)
            {
                try
                {
                    SetStatus("Checking available models...", 20);
                    var json = DownloadString(endpoint, apiKey);
                    var models = ParseModels(json);
                    if (models.Count == 0)
                    {
                        sawEmptyModelList = true;
                        throw new InvalidOperationException("The GESIS AI Server returned no models for this API key.");
                    }

                    models.Sort((left, right) => String.Compare(left.Name, right.Name, StringComparison.CurrentCultureIgnoreCase));
                    return models;
                }
                catch (WebException ex)
                {
                    lastError = ex;
                    var response = ex.Response as HttpWebResponse;
                    if (response != null && (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden))
                    {
                        throw new InvalidOperationException("The API key was rejected by the GESIS AI Server.");
                    }
                }
                catch (Exception ex)
                {
                    lastError = ex;
                }
            }

            if (lastError is WebException)
            {
                throw new InvalidOperationException("The installer could not reach the GESIS AI Server or could not retrieve its model list.");
            }

            if (sawEmptyModelList)
            {
                throw new InvalidOperationException("No models are available for this API key.");
            }

            throw new InvalidOperationException("The GESIS AI Server returned a model list in an unexpected format.");
        }

        private static List<ModelOption> ParseModels(string json)
        {
            var serializer = new JavaScriptSerializer();
            var parsed = serializer.DeserializeObject(json);
            var modelItems = FindModelItems(parsed);
            if (modelItems == null)
            {
                throw new InvalidOperationException("The server returned a model list in an unexpected format.");
            }

            var byId = new Dictionary<string, ModelOption>(StringComparer.OrdinalIgnoreCase);
            foreach (var item in modelItems)
            {
                var model = ToModelOption(item);
                if (model != null && !byId.ContainsKey(model.Id))
                {
                    byId.Add(model.Id, model);
                }
            }

            return new List<ModelOption>(byId.Values);
        }

        private static object[] FindModelItems(object parsed)
        {
            var array = parsed as object[];
            if (array != null)
            {
                return array;
            }

            var dictionary = parsed as Dictionary<string, object>;
            if (dictionary == null)
            {
                return null;
            }

            var keys = new[] { "data", "models" };
            foreach (var key in keys)
            {
                if (dictionary.ContainsKey(key))
                {
                    var nestedArray = dictionary[key] as object[];
                    if (nestedArray != null)
                    {
                        return nestedArray;
                    }
                }
            }

            return null;
        }

        private static ModelOption ToModelOption(object item)
        {
            var id = "";
            var name = "";

            var text = item as string;
            if (text != null)
            {
                id = text.Trim();
                name = PrettyName(id);
            }
            else
            {
                var dictionary = item as Dictionary<string, object>;
                if (dictionary == null)
                {
                    return null;
                }

                id = GetStringValue(dictionary, "id");
                if (id.Length == 0)
                {
                    id = GetStringValue(dictionary, "model");
                }

                name = GetStringValue(dictionary, "name");
                if (name.Length == 0)
                {
                    name = GetStringValue(dictionary, "title");
                }

                if (name.Length == 0)
                {
                    name = PrettyName(id);
                }
            }

            if (id.Length == 0)
            {
                return null;
            }

            return new ModelOption(id, name);
        }

        private static string GetStringValue(Dictionary<string, object> dictionary, string key)
        {
            if (!dictionary.ContainsKey(key) || dictionary[key] == null)
            {
                return "";
            }

            return Convert.ToString(dictionary[key]).Trim();
        }

        private static string PrettyName(string modelId)
        {
            if (String.IsNullOrWhiteSpace(modelId))
            {
                return "";
            }

            return modelId.Replace("-", " ").Replace("_", " ");
        }

        private List<ModelOption> GetSelectedModels()
        {
            SyncVisibleModelSelection();
            var selected = new List<ModelOption>();
            foreach (var model in availableModels)
            {
                if (model.IsSelected)
                {
                    selected.Add(model);
                }
            }

            return selected;
        }

        private void RefreshModelList()
        {
            var filter = modelFilterBox.Text.Trim();
            modelGridPanel.SuspendLayout();
            try
            {
                modelGridPanel.Controls.Clear();
                modelGridPanel.ColumnStyles.Clear();
                modelGridPanel.RowStyles.Clear();

                var visibleModels = new List<ModelOption>();
                foreach (var model in availableModels)
                {
                    if (filter.Length > 0 &&
                        model.Id.IndexOf(filter, StringComparison.OrdinalIgnoreCase) < 0 &&
                        model.Name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) < 0)
                    {
                        continue;
                    }

                    visibleModels.Add(model);
                }

                var columns = GetModelGridColumnCount();
                modelGridPanel.ColumnCount = columns;
                modelGridPanel.RowCount = Math.Max(1, (int)Math.Ceiling(visibleModels.Count / (double)columns));

                for (var column = 0; column < columns; column++)
                {
                    modelGridPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100F / columns));
                }

                for (var row = 0; row < modelGridPanel.RowCount; row++)
                {
                    modelGridPanel.RowStyles.Add(new RowStyle(SizeType.AutoSize));
                }

                for (var i = 0; i < visibleModels.Count; i++)
                {
                    var model = visibleModels[i];
                    var checkBox = new CheckBox
                    {
                        Text = model.ToString(),
                        Checked = model.IsSelected,
                        AutoSize = true,
                        MaximumSize = new Size(GetModelColumnTextWidth(columns), 0),
                        Margin = new Padding(0, 4, 18, 4),
                        Tag = model
                    };
                    checkBox.CheckedChanged += ModelCheckBox_CheckedChanged;

                    var row = i / columns;
                    var column = i % columns;
                    modelGridPanel.Controls.Add(checkBox, column, row);
                }
            }
            finally
            {
                modelGridPanel.ResumeLayout(true);
            }
        }

        private void SyncVisibleModelSelection()
        {
            foreach (Control control in modelGridPanel.Controls)
            {
                var checkBox = control as CheckBox;
                if (checkBox == null)
                {
                    continue;
                }

                var model = checkBox.Tag as ModelOption;
                if (model != null)
                {
                    model.IsSelected = checkBox.Checked;
                }
            }
        }

        private void SetVisibleModelSelection(bool selected)
        {
            foreach (Control control in modelGridPanel.Controls)
            {
                var checkBox = control as CheckBox;
                if (checkBox == null)
                {
                    continue;
                }

                var model = checkBox.Tag as ModelOption;
                if (model != null)
                {
                    model.IsSelected = selected;
                    checkBox.Checked = selected;
                }
            }
        }

        private void ModelCheckBox_CheckedChanged(object sender, EventArgs e)
        {
            var checkBox = sender as CheckBox;
            if (checkBox == null)
            {
                return;
            }

            var model = checkBox.Tag as ModelOption;
            if (model != null)
            {
                model.IsSelected = checkBox.Checked;
            }
        }

        private int GetModelGridColumnCount()
        {
            var workingArea = Screen.FromControl(this).WorkingArea;
            if (workingArea.Width >= 1200 && availableModels.Count >= 9)
            {
                return 3;
            }

            if (workingArea.Width >= 800 && availableModels.Count >= 4)
            {
                return 2;
            }

            return 1;
        }

        private int GetModelColumnTextWidth(int columns)
        {
            var contentWidth = Math.Max(420, ClientSize.Width - 96);
            return Math.Max(220, (contentWidth / Math.Max(1, columns)) - 28);
        }

        private void ResizeForModelGrid()
        {
            if (InvokeRequired)
            {
                BeginInvoke(new Action(ResizeForModelGrid));
                return;
            }

            if (WindowState == FormWindowState.Maximized)
            {
                return;
            }

            var workingArea = Screen.FromControl(this).WorkingArea;
            var maxWidth = (int)(workingArea.Width * 0.92);
            var maxHeight = (int)(workingArea.Height * 0.92);
            var columns = GetModelGridColumnCount();
            var rows = Math.Max(1, (int)Math.Ceiling(availableModels.Count / (double)columns));
            var desiredWidth = columns >= 3 ? 980 : columns == 2 ? 820 : 680;
            var desiredHeight = 430 + (rows * Math.Max(34, Font.Height + 18));

            Width = Math.Min(Math.Max(Width, desiredWidth), maxWidth);
            Height = Math.Min(Math.Max(Height, desiredHeight), maxHeight);
            CenterToScreen();
        }

        private static string JsonEscape(string value)
        {
            if (value == null)
            {
                return "";
            }

            return value
                .Replace("\\", "\\\\")
                .Replace("\"", "\\\"")
                .Replace("\r", "\\r")
                .Replace("\n", "\\n")
                .Replace("\t", "\\t");
        }

        private static string DownloadString(string url)
        {
            using (var client = CreateWebClient())
            {
                return client.DownloadString(url);
            }
        }

        private static string DownloadString(string url, string apiKey)
        {
            using (var client = CreateWebClient())
            {
                client.Headers.Add("Authorization", "Bearer " + apiKey);
                return client.DownloadString(url);
            }
        }

        private static WebClient CreateWebClient()
        {
            var client = new WebClient();
            client.Headers.Add("Accept", "application/vnd.github+json");
            client.Headers.Add("User-Agent", "GESIS-OpenCode-Installer");
            return client;
        }

        private void SetBusy(bool busy)
        {
            installButton.Enabled = !busy;
            checkApiKeyButton.Enabled = !busy;
            backButton.Enabled = !busy;
            selectAllButton.Enabled = !busy;
            selectNoneButton.Enabled = !busy;
            apiKeyBox.Enabled = !busy;
            if (!busy && installButton.Visible)
            {
                apiKeyBox.Enabled = false;
            }
            modelFilterBox.Enabled = !busy;
            modelGridPanel.Enabled = !busy;
            skipDesktopCheckBox.Enabled = !busy;
            progressBar.Style = busy ? ProgressBarStyle.Marquee : ProgressBarStyle.Continuous;
            if (!busy)
            {
                progressBar.Style = ProgressBarStyle.Continuous;
            }
        }

        private void SetStatus(string text, int progress)
        {
            if (InvokeRequired)
            {
                BeginInvoke(new Action<string, int>(SetStatus), text, progress);
                return;
            }

            progressBar.Style = ProgressBarStyle.Continuous;
            progressBar.Value = Math.Max(0, Math.Min(100, progress));
            statusLabel.Text = text;
        }
    }

    internal sealed class ModelOption
    {
        public ModelOption(string id, string name)
        {
            Id = id;
            Name = String.IsNullOrWhiteSpace(name) ? id : name;
            IsSelected = true;
        }

        public string Id { get; private set; }
        public string Name { get; private set; }
        public bool IsSelected { get; set; }

        public override string ToString()
        {
            if (String.Equals(Id, Name, StringComparison.OrdinalIgnoreCase))
            {
                return Id;
            }

            return Name + " (" + Id + ")";
        }
    }
}