package main

import (
	"fmt"
	"strconv"
	"strings"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func createLocationTab(platform platformStruct) *fyne.Container {
	searchEntry := widget.NewEntry()
	searchEntry.SetPlaceHolder("Поиск Локаций ...")

	filteredEntries := platform.DciLocations
	list := widget.NewList(
		func() int {
			return len(filteredEntries)
		},
		func() fyne.CanvasObject {
			return container.NewVBox(
				widget.NewEntry(),
				widget.NewEntry(),
				widget.NewEntry(),
				widget.NewEntry(),
				widget.NewEntry(),
				widget.NewEntry(),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := filteredEntries[id]

			entryOne := box.Objects[0].(*widget.Entry)
			entryTwo := box.Objects[1].(*widget.Entry)
			entryThree := box.Objects[2].(*widget.Entry)
			entryFour := box.Objects[3].(*widget.Entry)
			entryFive := box.Objects[4].(*widget.Entry)
			entrySix := box.Objects[5].(*widget.Entry)

			entryOne.AlwaysShowValidationError = true
			entryOne.SetText(fmt.Sprintf("%d    Имя: %s    Главная локация: %d    Статус: %s (%s)", e.Id, e.Name, e.IsMain, e.Status, e.StatusInfo))
			entryTwo.SetText(fmt.Sprintf("SSH:    %s@%s:%d", e.SshUser, e.SshAddress, e.SshPort))
			entryThree.SetText(fmt.Sprintf("%s    Userspace: %d", e.SetupInfo, e.Userspace))
			entryFour.SetText(fmt.Sprintf("Настройки: %s", e.Settings))
			entryFive.SetText(fmt.Sprintf("Патч: %s", e.Patch))
			entrySix.SetText(fmt.Sprintf("DHCP: %s   Redis: %s   Nginx: %s   Netflow: %s   Proxy: %s", e.ParamsDhcp, e.ParamsRedis, e.ParamsNginx, e.ParamsNetflow, e.ProxyParams))
			entryOne.TextStyle.Bold = true
		},
	)
	searchEntry.OnChanged = func(text string) {
		if text == "" {
			filteredEntries = platform.DciLocations
		} else {
			filtered := []dciLocation{}
			lText := strings.ToLower(text)
			for _, elem := range platform.DciLocations {
				if strings.Contains(strings.ToLower(elem.Name), lText) || strings.Contains(strings.ToLower(elem.SshAddress), lText) {
					filtered = append(filtered, elem)
				}
			}
			filteredEntries = filtered
		}
		list.Refresh()
	}
	locationsTab := container.NewBorder(
		container.NewVBox(
			searchEntry,
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return locationsTab
}

// func createLocationComposeTab(platform platformStruct) *fyne.Container {
// 	// строка поиска
// 	searchEntry := widget.NewEntry()
// 	searchEntry.SetPlaceHolder("Поиск ...")

// 	// переменная с которой будем работать дальше при фильтрации, с пустым условием фильтрации равна всему списку
// 	filteredEntries := platform.DciLocationDockerComposes
// 	// создаём список, котрый будет отображаться в табе
// 	list := widget.NewList(
// 		// состоит из трёх функций, которые постоянно дургаются, когда скролишь список
// 		// первая возвращает длину списка, что даёт возможность получить id элемента
// 		func() int {
// 			return len(filteredEntries)
// 		},
// 		// вторая работает шаблоном показывая из каких элементов список будет состоять
// 		func() fyne.CanvasObject {
// 			return container.NewVBox(
// 				widget.NewLabel("имя"),
// 				widget.NewMultiLineEntry(),
// 			)
// 		},
// 		// третья функция формирует собственно список с данными
// 		func(id widget.ListItemID, obj fyne.CanvasObject) {
// 			box := obj.(*fyne.Container)
// 			e := filteredEntries[id]
// 			nameLabel := box.Objects[0].(*widget.Label)
// 			composeEntry := box.Objects[1].(*widget.Entry)

// 			nameLabel.SetText(fmt.Sprintf("%d   %s", e.Id, e.Name))
// 			nameLabel.TextStyle.Bold = true
// 			composeEntry.SetText(e.DockerCompose)
// 		},
// 	)
// 	// дальше формируем поисковую логику, которая вызывается при изменении строки
// 	searchEntry.OnChanged = func(text string) {
// 		if text == "" {
// 			filteredEntries = platform.DciLocationDockerComposes
// 		} else {
// 			filtered := []dciLocationDockerCompose{}
// 			lText := strings.ToLower(text)
// 			for _, elem := range platform.DciLocationDockerComposes {
// 				if strings.Contains(strings.ToLower(elem.Name), lText) || strings.Contains(strings.ToLower(elem.DockerCompose), lText) {
// 					filtered = append(filtered, elem)
// 				}
// 			}
// 			filteredEntries = filtered
// 		}
// 		list.Refresh()
// 	}
// 	locationsTab := container.NewBorder(
// 		container.NewVBox(
// 			searchEntry,
// 			widget.NewSeparator(),
// 		), nil, nil, nil,
// 		container.NewScroll(list),
// 	)
// 	return locationsTab
// }

func createTaskManagerFailedTab(platform platformStruct) *fyne.Container {
	searchEntry := widget.NewEntry()
	searchEntry.SetPlaceHolder("Поиск задач ...")

	filteredEntries := platform.TaskManagerTask
	list := widget.NewList(
		func() int {
			return len(filteredEntries)
		},
		func() fyne.CanvasObject {
			return container.NewVBox(
				widget.NewLabel("id name status"),
				widget.NewLabel("time"),
				widget.NewEntry(),
				widget.NewLabel("output"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := filteredEntries[id]
			idLabel := box.Objects[0].(*widget.Label)
			nameLabel := box.Objects[1].(*widget.Label)
			statusLabel := box.Objects[2].(*widget.Entry)
			timeLabel := box.Objects[3].(*widget.Label)

			idLabel.SetText(fmt.Sprintf("%d %s %s", e.Id, e.Name, e.Status))
			idLabel.TextStyle.Bold = true
			nameLabel.SetText(e.RegistrationTime)
			statusLabel.SetText(e.RequestInfo)
			timeLabel.SetText(e.Output)
		},
	)
	searchEntry.OnChanged = func(text string) {
		if text == "" {
			filteredEntries = platform.TaskManagerTask
		} else {
			filtered := []taskManagerTask{}
			lText := strings.ToLower(text)
			for _, elem := range platform.TaskManagerTask {
				if strings.Contains(strings.ToLower(elem.Name), lText) || strings.Contains(strings.ToLower(elem.Status), lText) {
					filtered = append(filtered, elem)
				}
			}
			filteredEntries = filtered
		}
		list.Refresh()
	}
	taskFailedTab := container.NewBorder(
		container.NewVBox(
			searchEntry,
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return taskFailedTab
}

func createHwByLocationsTab(platform platformStruct) *fyne.Container {
	searchEntry := widget.NewEntry()
	searchEntry.SetPlaceHolder("Поиск по локациям ...")

	filteredEntries := platform.HwByLocations
	list := widget.NewList(
		func() int {
			return len(filteredEntries)
		},

		func() fyne.CanvasObject {
			return container.NewHBox(
				widget.NewLabel("loc"),
				widget.NewLabel("serv"),
				widget.NewLabel("switch"),
				widget.NewLabel("pdu"),
				widget.NewLabel("ups"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := filteredEntries[id]
			loc := box.Objects[0].(*widget.Label)
			serv := box.Objects[1].(*widget.Label)
			sw := box.Objects[2].(*widget.Label)
			pdu := box.Objects[3].(*widget.Label)
			ups := box.Objects[4].(*widget.Label)

			loc.SetText(fmt.Sprintf("Локация: %d", e.Location))
			loc.TextStyle.Bold = true
			serv.SetText(fmt.Sprintf("Серверов: %d", e.Server))
			sw.SetText(fmt.Sprintf("Коммутаторов: %d", e.Switch))
			pdu.SetText(fmt.Sprintf("PDU: %d", e.Pdu))
			ups.SetText(fmt.Sprintf("UPS: %d", e.Ups))
		},
	)
	searchEntry.OnChanged = func(text string) {
		if text == "" {
			filteredEntries = platform.HwByLocations
		} else {
			filtered := []hwByLocation{}
			lText := strings.ToLower(text)
			for _, elem := range platform.HwByLocations {
				if strings.Contains(strconv.Itoa(elem.Location), lText) {
					filtered = append(filtered, elem)
				}
			}
			filteredEntries = filtered
		}
		list.Refresh()
	}
	tab := container.NewBorder(
		container.NewVBox(
			searchEntry,
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return tab
}

func createInstalledPluginTab(platform platformStruct) *fyne.Container {

	list := widget.NewList(
		func() int {
			return len(platform.InstalledPlugin)
		},
		func() fyne.CanvasObject {
			return container.NewHBox(
				widget.NewLabel("name"),
				widget.NewLabel("status"),
				widget.NewLabel("version"),
				widget.NewLabel("Curver"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := platform.InstalledPlugin[id]

			nameLabel := box.Objects[0].(*widget.Label)
			statLabel := box.Objects[1].(*widget.Label)
			verLabel := box.Objects[2].(*widget.Label)
			curverLabel := box.Objects[3].(*widget.Label)

			nameLabel.SetText(e.Name)
			nameLabel.TextStyle.Bold = true
			statLabel.SetText(e.Status)
			verLabel.SetText(e.Version)
			curverLabel.SetText(e.CurrentVersion)
		},
	)
	list.Refresh()
	tab := container.NewBorder(
		container.NewVBox(
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return tab
}

func createLdapTab(platform platformStruct) *fyne.Container {
	list := widget.NewList(
		func() int {
			return len(platform.Ldaps)
		},
		// Id       int    `json:"id"`
		// Name     string `json:"name"`
		// LastSync string `json:"last_sync"`
		func() fyne.CanvasObject {
			return container.NewHBox(
				widget.NewLabel("ldap"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := platform.Ldaps[id]

			ldapLabel := box.Objects[0].(*widget.Label)
			ldapLabel.SetText(fmt.Sprintf("%d  %s  Синхронизация: %s", e.Id, e.Name, e.LastSync))
		},
	)
	list.Refresh()
	tab := container.NewBorder(
		container.NewVBox(
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return tab
}

func createRepoTab(platform platformStruct) *fyne.Container {
	list := widget.NewList(
		func() int {
			return len(platform.Repos)
		},
		// Id   int    `json:"id"`
		// Name string `json:"name"`
		// Url  string `json:"url"`
		func() fyne.CanvasObject {
			return container.NewHBox(
				widget.NewLabel("id"),
				widget.NewLabel("name"),
				widget.NewLabel("url"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := platform.Repos[id]

			idLabel := box.Objects[0].(*widget.Label)
			nameLabel := box.Objects[1].(*widget.Label)
			urlLabel := box.Objects[2].(*widget.Label)

			idLabel.SetText(fmt.Sprintf("%d", e.Id))
			nameLabel.SetText(e.Name)
			urlLabel.SetText(e.Url)
		},
	)
	list.Refresh()
	tab := container.NewBorder(
		container.NewVBox(
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return tab
}

func createOsTemplateTab(platform platformStruct) *fyne.Container {
	searchEntry := widget.NewEntry()
	searchEntry.SetPlaceHolder("Поиск ...")

	filteredEntries := platform.OsTemplates
	list := widget.NewList(
		func() int {
			return len(filteredEntries)
		},
		// Id            int    `json:"id"`
		// Name          string `json:"name"`
		// Filename      string `json:"filename"`
		// Macro         string `json:"macro"`
		// Metainfo      string `json:"metainfo"`
		// DirectoryName string `json:"directory_name"`
		// Repository    int    `json:"repository"`
		// Size          int    `json:"size"`
		func() fyne.CanvasObject {
			return container.NewVBox(
				widget.NewLabel("id-name-filename-directoryname-size"),
				widget.NewLabel("macro-metainfo-reposiztory"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := filteredEntries[id]
			labelFirst := box.Objects[0].(*widget.Label)
			labelSecond := box.Objects[1].(*widget.Label)

			labelFirst.SetText(fmt.Sprintf("%d %s %s %s размер: %d", e.Id, e.Name, e.Filename, e.DirectoryName, e.Size))
			labelFirst.Selectable = true
			labelSecond.SetText(fmt.Sprintf("макросы: %s  мета: %s  репозиторий: %d", e.Macro, e.Metainfo, e.Repository))
			labelSecond.Selectable = true
		},
	)
	searchEntry.OnChanged = func(textRaw string) {
		if textRaw == "" {
			filteredEntries = platform.OsTemplates
		} else {
			filtered := []osTemplate{}
			text := strings.ToLower(textRaw)
			for _, elem := range platform.OsTemplates {
				if strings.Contains(strings.ToLower(elem.Name), text) || strings.Contains(strings.ToLower(elem.Filename), text) || strings.Contains(strings.ToLower(elem.Metainfo), text) || strings.Contains(strings.ToLower(elem.DirectoryName), text) {
					filtered = append(filtered, elem)
				}
			}
			filteredEntries = filtered
		}
		list.Refresh()
	}
	osTemplTab := container.NewBorder(
		container.NewVBox(
			searchEntry,
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return osTemplTab
}

func createBackupTasksTab(platform platformStruct) *fyne.Container {
	// Id             int    `json:"id"`
	// Enabled        int    `json:"enabled"`
	// CronExpression string `json:"cron_expression"`
	// LimitCount     int    `json:"limit_count"`
	// LimitSizeMib   int    `json:"limit_size_mib"`
	list := widget.NewList(
		func() int {
			return len(platform.BackupTasks)
		},
		func() fyne.CanvasObject {
			return container.NewHBox(
				widget.NewLabel("id"),
				widget.NewLabel("enabled"),
				widget.NewLabel("cron"),
				widget.NewLabel("count"),
				widget.NewLabel("size"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := platform.BackupTasks[id]

			label0 := box.Objects[0].(*widget.Label)
			label1 := box.Objects[1].(*widget.Label)
			label2 := box.Objects[2].(*widget.Label)
			label3 := box.Objects[3].(*widget.Label)
			label4 := box.Objects[4].(*widget.Label)

			label0.SetText(strconv.Itoa(e.Id))
			label1.SetText(fmt.Sprintf("включено: %d", e.Enabled))
			label2.SetText(e.CronExpression)
			label3.SetText(fmt.Sprintf("количество копий: %d", e.LimitCount))
			label4.SetText(fmt.Sprintf("размер: %d", e.LimitSizeMib))
		},
	)
	list.Refresh()
	tab := container.NewBorder(
		container.NewVBox(
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return tab
}

func createCopiedFileListTab(platform platformStruct) *fyne.Container {
	searchEntry := widget.NewEntry()
	searchEntry.SetPlaceHolder("Поиск ...")

	filteredEntries := platform.CopiedFiles.FileNames
	list := widget.NewList(
		func() int {
			return len(filteredEntries)
		},
		func() fyne.CanvasObject {
			return container.NewVBox(
				widget.NewLabel("fileName"),
			)
		},
		func(id widget.ListItemID, obj fyne.CanvasObject) {
			box := obj.(*fyne.Container)
			e := filteredEntries[id]
			fileName := box.Objects[0].(*widget.Label)

			fileName.SetText(e)
			fileName.Selectable = true

		},
	)
	searchEntry.OnChanged = func(text string) {
		if text == "" {
			filteredEntries = platform.CopiedFiles.FileNames
		} else {
			var filtered []string
			lText := strings.ToLower(text)
			for _, elem := range platform.CopiedFiles.FileNames {
				if strings.Contains(strings.ToLower(elem), lText) {
					filtered = append(filtered, elem)
				}
			}
			filteredEntries = filtered
		}
		list.Refresh()
	}
	tab := container.NewBorder(
		container.NewVBox(
			searchEntry,
			widget.NewSeparator(),
		), nil, nil, nil,
		container.NewScroll(list),
	)
	return tab
}

func createLicenseTab(platform platformStruct) *fyne.Container {
	licCheck := widget.NewMultiLineEntry()
	licCheck.SetText(platform.License.LicenseCheck)
	licInfo := widget.NewMultiLineEntry()
	licInfo.SetText(platform.License.LicenseInfo)
	licInfo.MultiLine = true
	licInfo.SetMinRowsVisible(20)
	tab := container.NewBorder(
		container.NewVBox(
			licCheck,
			licInfo,
		), nil, nil, nil,
	)
	return tab
}