package base

import (
	"fmt"
	"log"
	"strconv"
	"strings"
	"sync"
	"time"

	"wartank/pkg/components/section"
	"wartank/pkg/components/sound"
	"wartank/pkg/types"
	"wartank/server/serv_bots/warbot/angar/base/arsenal"
	"wartank/server/serv_bots/warbot/angar/base/bank"
	"wartank/server/serv_bots/warbot/angar/base/basenet"
	"wartank/server/serv_bots/warbot/angar/base/market"
	"wartank/server/serv_bots/warbot/angar/base/mine"
	"wartank/server/serv_bots/warbot/angar/base/polygon"
)

/*
	Объект базы в игре.
*/

const (
	времОжидПлат    = 60   // Время ожидания платного ускорения
	времОжидБесплат = 1810 // Время ожидания бесплатного ускорения

)

// База -- объект базы
type База struct {
	*section.Section
	сеть      *basenet.BaseNet
	арсенал   *arsenal.Арсенал
	банк      *bank.Банк
	полигон   *polygon.Polygon
	шахта     *mine.Шахта
	ранок     *market.Рынок
	времОстат int // Сколько времени спать до опроса базы
	блок      sync.Mutex
}

// НовБаза -- возвращает новую базу бота
func НовБаза(ангар types.ИАнгар) (*База, error) {
	section, err := section.NewSection(ангар.Бот(), "База", `<title>База</title>`)
	if err != nil {
		return nil, fmt.Errorf("NewBase(): in create ISection, err=\n\t%w", err)
	}
	log.Printf("NewBase(): %q\n", section.Бот().Имя())
	sf := &База{
		Section: section,
	}
	{ // База в сети
		sf.сеть, err = basenet.NewBaseNet(sf)
		if err != nil {
			return nil, fmt.Errorf("NewBase(): in create NetBase, err=\n\t%w", err)
		}
	}
	{ // Arsenal
		sf.арсенал, err = arsenal.НовАрсенал(sf)
		if err != nil {
			return nil, fmt.Errorf("NewBase(): in create IArsenal, err=\n\t%w", err)
		}
	}
	{ // Bank
		sf.банк, err = bank.НовБанк(sf)
		if err != nil {
			return nil, fmt.Errorf("NewBase(): in create IBank, err=\n\t%w", err)
		}
	}
	{ // Mine
		sf.шахта, err = mine.НовШахта(sf)
		if err != nil {
			return nil, fmt.Errorf("NewBase(): in create IMine, err=\n\t%w", err)
		}
	}
	{ // Market
		sf.ранок, err = market.НовРынок(sf)
		if err != nil {
			return nil, fmt.Errorf("NewBase(): при создании IMarket, err=\n\t%w", err)
		}
	}
	{ // Polygon
		sf.полигон, err = polygon.NewPolygon(sf)
		if err != nil {
			return nil, fmt.Errorf("NewBase(): in create IPolygon, err=\n\t%w", err)
		}
	}
	return sf, nil
}

// Запускает базу в обработку
func (sf *База) Пуск() error {
	log.Printf("Base.Run()\n")
	if err := sf.runComponent(); err != nil {
		return fmt.Errorf("Base.Run(): run, err=\n\t%w", err)
	}
	go sf.пуск()
	return nil
}

// Собственная работа
func (sf *База) пуск() {
	фнЦикл := func() {
		if err := sf.сеть.UpdateLst(); err != nil { // Обновить состояние базы
			log.Printf("ERRO Base.Run(): при обновлении базы, err=\n\t%v\n", err)
		}
		sf.проверитьПолигонУсиление()              // Проверить усиление полигона
		if err := sf.проверитьБанк(); err != nil { // Проверка режимов банка
			log.Printf("ERRO Base.Run(): при проверке банка, err=\n\t%v\n", err)
		}
		sf.проверитьАрсенал() // Проверка арсенала
		sf.проверитьШахту()   // Проверка шахты
		sf.setCountDown()     // Установка счётчика времени
		time.Sleep(time.Second * time.Duration(sf.времОстат))
	}
	for {
		select {
		case <-sf.Кнт().Done():
			sf.ВремяОпрос().Стоп()
			return
		// case <-sf.ВремяОпрос().КаналСиг():
		// 	фнЦикл()
		default:
			фнЦикл()
			time.Sleep(time.Minute * 1)
		}
	}
}

// Запускает компоненты
func (sf *База) runComponent() error {
	log.Printf("Base.run()\n")
	sf.блок.Lock()
	defer sf.блок.Unlock()
	if err := sf.арсенал.Пуск(); err != nil {
		return fmt.Errorf("Base.run(): in run IArsenal, err=\n\t%w", err)
	}
	if err := sf.банк.Пуск(); err != nil {
		return fmt.Errorf("Base.run(): in run IBank, err=\n\t%w", err)
	}
	if err := sf.шахта.Пуск(); err != nil {
		return fmt.Errorf("Base.run(): in run IMine, err=\n\t%w", err)
	}
	if err := sf.ранок.Пуск(); err != nil {
		return fmt.Errorf("Base.run(): in run IMarket, err=\n\t%w", err)
	}
	if err := sf.полигон.Run(); err != nil {
		return fmt.Errorf("Base.run(): in run IPolygon, err=\n\t%w", err)
	}
	return nil
}

// Выбирает время обновления базы по компонентам
func (sf *База) setCountDown() {
	timeBase := sf.банк.ВремяОпрос().Получ()
	timeCount := timeBase
	timeArsenal := sf.арсенал.ВремяОпрос().Получ()
	timeMine := sf.шахта.ВремяОпрос().Получ()
	if timeArsenal < timeCount {
		timeCount = timeArsenal
	}
	if timeMine < timeCount {
		timeCount = timeMine
	}
	if timeCount <= 1 {
		sf.времОстат = 5
		return
	}
	if timeCount > (600) {
		sf.времОстат = 600
	}
	sf.SetCountDown(timeCount)
}

// Арсенал -- возвращает объект арсенала
func (sf *База) Арсенал() types.ИАрсенал {
	return sf.арсенал
}

// Банк -- возвращает объект банка
func (sf *База) Банк() types.ИБанк {
	sf.блок.Lock()
	defer sf.блок.Unlock()
	return sf.банк
}

// Полигон -- возвращает объект полигона
func (sf *База) Полигон() types.ИПолигон {
	return sf.полигон
}

// Шахта -- возвращает объект шахты
func (sf *База) Шахта() types.ИШахта {
	return sf.шахта
}

// Рынок -- возвращает объект рынка
func (sf *База) Рынок() types.ИРынок {
	return sf.ранок
}

// Проверяет на забрать шахту
func (sf *База) проверитьШахту() {
	if sf.шахта.Руда().Получ() == 0 {
		sf.шахтаСтатаОбновить()
	}
	sf.шахтаАпгрейдФорсаж() // Нужно ли ускорить апгрейд шахты
	if sf.шахта.РежимТекущ().Получ() == "upgrade" {
		return
	}
	sf.шахтаСтатаОбновить()
	sf.шахтаЗабрать() // Нужно ли забрать из шахты
	sf.шахтаДелать()  // Нужно ли производство в шахте

	sf.checkMineTime()
}

// Проверяет время ожидания шахты
func (sf *База) checkMineTime() {
	var (
		lstBase = sf.СписПолучить()
		strOut  string
		isFind  bool
		ind     int
	)
	for ind, strOut = range lstBase {
		if !strings.Contains(strOut, `<span class="green2">Шахта - `) {
			continue
		}
		ind += 11
		strOut = lstBase[ind]
		isFind = true
		break
	}
	if !isFind {
		return
	}
	if !strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
		return
	}
	lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
	strTime := lstTime[1]
	lstTime = strings.Split(strTime, `</span></span></div></td>`)
	strTime = lstTime[0]
	if err := sf.шахта.ParseCountDown(strTime); err != nil {
		log.Printf("ERRO Base.checkMineTime(): при установке обратного отсчёта(%v), err=\n\t%v\n", strTime, err)
	}
}

// Проверяет на забор из шахты
func (sf *База) шахтаЗабрать() {
	var (
		strOut  string
		ind     int
		isFind  bool
		lstBase = sf.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `<span class="green2">Шахта -`) {
			isFind = true
			break
		}
	}
	if !isFind {
		return
	}
	ind += 18
	strOut = lstBase[ind]
	if !strings.Contains(strOut, `"><span><span>Забрать</span></span></a>`) {
		return
	}
	lstLink := strings.Split(strOut, `<a class="simple-but border" href="`)
	strLink := lstLink[1]
	lstLink = strings.Split(strLink, `"><span><span>Забрать</span></span></a>`)
	strLink = "https://wartank.ru/" + lstLink[0]
	lstBase1, err := sf.сеть.Get(strLink)
	if err != nil {
		// log._rintf("ERRO Base.checkMineGet(): при выполнении Get-запроса 'забрать', err=\n\t%v\n", err)
		return
	}
	if err = sf.шахта.СтрОбновить(lstBase1); err != nil {
		// log._rintf("ERRO Base.checkMineGet(): при обновлении lstMine, err=\n\t%v\n", err)
		return
	}
	sf.шахта.Сделать()
}

// Проверка статистики шахты
func (sf *База) шахтаСтатаОбновить() {
	var (
		lstMine = sf.СписПолучить()
		strOut  string
		isFind  bool
		ind     int
	)
	{ // Ищем руду
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/>`) {
				isFind = true
				break
			}
		}
		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `) {
			lstRuda := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/ore.png?2" alt="Руда" title="Руда"/> `)
			strRuda := lstRuda[1]
			lstRuda = strings.Split(strRuda, ` &nbsp;&nbsp;</span>`)
			strRuda = lstRuda[0]
			iRuda, err := strconv.Atoi(strRuda)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): руда(%v) не число, err=\n\t%v\n", strRuda, err)
				return
			}
			sf.шахта.Руда().Уст(iRuda)
		}
	}
	{ // Ищем железо
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
				isFind = true
				break
			}
		}
		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `) {
			lstFerrum := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/iron.png?2" alt="Железо" title="Железо"/> `)
			strFerrum := lstFerrum[1]
			lstFerrum = strings.Split(strFerrum, ` &nbsp;&nbsp;</span>`)
			strFerrum = lstFerrum[0]
			iFerrum, err := strconv.Atoi(strFerrum)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): железо(%v) не число, err=\n\t%v\n", strFerrum, err)
				return
			}
			sf.шахта.Железо().Уст(iFerrum)
		}
	}
	{ // Ищем сталь
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
				isFind = true
				break
			}
		}
		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `) {
			lstSteel := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/steel.png?2" alt="Сталь" title="Сталь"/> `)
			strSteel := lstSteel[1]
			lstSteel = strings.Split(strSteel, ` &nbsp;&nbsp;</span>`)
			strSteel = lstSteel[0]
			iSteel, err := strconv.Atoi(strSteel)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): сталь(%v) не число, err=\n\t%v\n", strSteel, err)
				return
			}
			sf.шахта.Сталь().Уст(iSteel)
		}
	}
	{ // Ищем свинец
		for _, strOut = range lstMine {
			if strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
				isFind = true
				break
			}
		}
		if isFind && strings.Contains(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `) {
			lstPlumbum := strings.Split(strOut, `<span class="nwr"><img class="rico vm" src="/images/icons/plumbum.png?2" alt="Свинец" title="Свинец"/> `)
			strPlumbum := lstPlumbum[1]
			lstPlumbum = strings.Split(strPlumbum, ` &nbsp;&nbsp;</span>`)
			strPlumbum = lstPlumbum[0]
			iPlumbum, err := strconv.Atoi(strPlumbum)
			if err != nil {
				log.Printf("ERRO Base.checkMineStat(): свинец(%v) не число, err=\n\t%v\n", strPlumbum, err)
				return
			}
			sf.шахта.Свинец().Уст(iPlumbum)
		}
	}
	{ // Ищем время обработки и режим
		lstBase := sf.СписПолучить()
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `<span class="green2">Шахта - `) {
				isFind = true
				ind += 11
				strOut = lstBase[ind]
				break
			}
		}
		if isFind && strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
			lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
			strTime := lstTime[1]
			lstTime = strings.Split(strTime, `</span></span></div></td>`)
			strTime = lstTime[0]
			if err := sf.шахта.ParseCountDown(strTime); err != nil {
				log.Printf("ERRO Base.checkMineStat(): при установке времени ожидания шахты(%v)\n\terr=%v\n", strTime, err)
			}
		}

		ind -= 3
		if ind < 0 {
			log.Printf("Base.checkMineStat(): отрицательный индекс(%v)!\n", ind)
			return
		}
		strOut = lstBase[ind]
		switch {
		case strings.Contains(strOut, `/images/icons/iron.png`): // Железо
			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/iron.png?2" alt="iron"/>&nbsp;`)
			strNum := lstNum[1]
			lstNum = strings.Split(strNum, `</div></td>`)
			strNum = lstNum[0]
			sf.шахта.РежимТекущ().РежимУст("Железо-" + strNum)
		case strings.Contains(strOut, `/images/icons/ore.png`): // Руда
			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/ore.png?2" alt="ore"/>&nbsp;`)
			strNum := lstNum[1]
			lstNum = strings.Split(strNum, `</div></td>`)
			strNum = lstNum[0]
			sf.шахта.РежимТекущ().РежимУст("Руда-" + strNum)
		case strings.Contains(strOut, `/images/icons/steel.png`): // Руда
			lstNum := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/steel.png?2" alt="steel"/>&nbsp;`)
			strNum := lstNum[1]
			lstNum = strings.Split(strNum, `</div></td>`)
			strNum = lstNum[0]
			sf.шахта.РежимТекущ().РежимУст("Сталь-" + strNum)
		}
	}
}

// Проверяет на необходимость производства (* здесь этого быть не должно *)
func (sf *База) шахтаДелать() {
	var (
		strOut  string
		ind     int
		isFind  bool
		lstBase = sf.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `<span class="green2">Шахта -`) {
			isFind = true
			ind += 12
			strOut = lstBase[ind]
			break
		}
	}
	if !isFind {
		return
	}
	if !strings.Contains(strOut, `"><span><span>Производство</span></span></a>`) {
		return
	}
	sf.шахта.КолвоРаботаСейчас().Уст(0)
}

// Проверяет режимы арсенала
func (sf *База) проверитьАрсенал() {
	// countTime := sf.арсенал.ВремяОпрос().Получ()
	// if countTime > 3 {
	// 	return
	// }
	if err := sf.арсенал.Обновить(); err != nil {
		// log._rintf("ERRO Base.checkArsenal(): при обновлении арсенала, err=\n\t%v\n", err)
		return
	}
	if mode := sf.арсенал.РежимТекущ().Режим(); mode == "" {
		sf.проверитьАрсеналРежим()
	}
	sf.проверитьАрсеналУскорение() // Нужно ли ускорить апгрейд арсенала
	if sf.арсенал.РежимТекущ().Получ() == "upgrade" {
		return
	}
	sf.проверитьАрсеналЗабрать() // Нужно ли забрать оружие
	sf.проверитьАрсеналВремя()
	sf.проверитьАрсеналРежим()
}

// Проверяет время готовности арсенала
func (sf *База) проверитьАрсеналВремя() {
	var (
		lstBase = sf.СписПолучить()
		ind     int
		strOut  string
		isFind  bool
	)
	for ind, strOut = range lstBase {
		if !strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
			continue
		}
		ind += 10
		strOut = lstBase[ind]
		isFind = true
		break
	}
	if !isFind {
		return
	}
	if !strings.Contains(strOut, ":") {
		return
	}
	lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
	if len(lstTime) != 2 { // Возможно, производство
		return
	}
	strTime := lstTime[1]
	lstTime = strings.Split(strTime, `</span></span></div></td>`)
	strTime = lstTime[0]
	if err := sf.арсенал.ParseCountDown(strTime); err != nil {
		log.Printf("ERRO Base.checkArsenalTime(): при установке времени ожидания арсенала(%v)\n\terr=%v\n", strTime, err)
	}
}

// Проверяет на забрать оружейную
func (sf *База) проверитьАрсеналЗабрать() {
	var (
		strOut      string
		ind         int
		еслиНайдено bool
		lstBase     = sf.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
			еслиНайдено = true
			ind += 17
			strOut = lstBase[ind]
			break
		}
	}
	if !еслиНайдено {
		return
	}
	if !strings.Contains(strOut, `"><span><span>Забрать</span></span></a>`) {
		return
	}
	lstLink := strings.Split(strOut, `<a class="simple-but border" href="`)
	strLink := lstLink[1]
	lstLink = strings.Split(strLink, `"><span><span>Забрать</span></span></a>`)
	// https://wartank.ru/buildings?80-1.ILinkListener-buildings-0-building-rootBlock-actionPanel-takeProductionLink
	strLink = "https://wartank.ru/" + lstLink[0]
	var (
		лстАрсенал []string
		ош         error
	)
	фнЗабрать := func() bool {
		time.Sleep(time.Millisecond * 100)
		лстАрсенал, ош = sf.сеть.Get(strLink)
		if ош != nil {
			// log._rintf("ERRO Base.checkArsenalGet(): при выполнении Get-запроса 'забрать', err=\n\t%v\n", err)
			return false
		}
		if len(лстАрсенал) == 0 {
			// log._rintf("ERRO Base.checkArsenalGet(): len lstBase(%v)==0", len(lstBase))
			return false
		}
		for _, strOut = range лстАрсенал {
			if strings.Contains(strOut, `<title>Производство</title>`) {
				return false
			}
		}
		return true
	}
	for !фнЗабрать() {
	}
	sf.арсенал.SetCountDown(1)
	if ош = sf.СтрОбновить(лстАрсенал); ош != nil {
		log.Printf("ERRO Base.checkArsenalGet(): при обновлении lstBase, err=\n\t%v\n", ош)
	}
	if ош = sf.арсенал.СтрОбновить(лстАрсенал); ош != nil {
		log.Printf("ERRO Base.checkArsenalGet(): при обновлении lstArsenal, err=\n\t%v\n", ош)
	}
}

// Проверяет режим производства арсенала
func (sf *База) проверитьАрсеналРежим() {
	var (
		strOut  string
		lstBase = sf.СписПолучить()
	)
	for _, strOut = range lstBase {
		if strings.Contains(strOut, `HollowCharge.png`) {
			sf.арсенал.РежимТекущ().РежимУст("кумулятивы")
			return
		}
		if strings.Contains(strOut, `ArmorPiercing.png`) {
			sf.арсенал.РежимТекущ().РежимУст("бронебойки")
			return
		}
		if strings.Contains(strOut, `HighExplosive.png`) {
			sf.арсенал.РежимТекущ().РежимУст("фугасы")
			return
		}
		if strings.Contains(strOut, `repairkit.gif`) {
			sf.арсенал.РежимТекущ().РежимУст("ремка")
			return
		}
	}
}

// Проверяет на ускорение апгрейда арсенала
func (sf *База) проверитьАрсеналУскорение() {
	var (
		ind     int
		strOut  = ""
		isFind  bool
		lstBase = sf.СписПолучить()
	)
	{ // Проверка на платное ускорение апгрейда + время
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
				// Убедиться что есть строка платного ускорения
				isFind = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if !isFind {
			return
		}
		{ // Платное ускорение
			if strings.Contains(strOut, `Ускорить за`) {
				if err := sf.арсенал.SetCountDown(времОжидПлат); err != nil {
					log.Printf("WARN Base.checkArsenalForce(): при установке платного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидПлат, err)
				}
				sf.арсенал.РежимТекущ().Уст("upgrade")
				sf.арсенал.РежимТекущ().РежимУст("апгрейд")
				return
			}
		}
	}
	{ // Проверка на бесплатное ускорение апгрейда
		isFind = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит снаряды, ремкомплекты<br/>`) {
				// Убедиться что есть строка платного ускорения
				isFind = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if !isFind {
			return
		}
		if !strings.Contains(strOut, `>Ускорение<`) {
			return
		}
		sf.арсенал.РежимТекущ().Уст("upgrade")
		lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
		strLink := lstLink[1]
		lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
		strLink = "https://wartank.ru/" + lstLink[0]
		lstBase, err := sf.сеть.Get(strLink)
		if err != nil {
			// log._rintf("ERRO NetBank.checkArsenalForce(): при GET-запросе на бесплатном ускорении апгрейда арсенала, err=\n\t%v\n", err)
			return
		}
		// sound.ArsenalForce()
		if err := sf.СтрОбновить(lstBase); err != nil {
			// log._rintf("ERRO NetBank.checkArsenalForce(): при обновлении lstBase, err=\n\t%v\n", err)
			return
		}
		sf.арсенал.РежимТекущ().Уст("upgrade")
		sf.арсенал.РежимТекущ().РежимУст("апгрейд")
		if err := sf.арсенал.SetCountDown(времОжидБесплат); err != nil {
			log.Printf("WARN Base.checkArsenalForce(): при установке бесплатного времени ускорения апгрейда арсенала(%v)\n\terr=%v\n", времОжидБесплат, err)
		}
	}
	// Все проверки прошли -- это просто работа
	sf.арсенал.РежимТекущ().Уст("work")
}

// Проверяет режим банка
func (sf *База) проверитьБанк() error {
	if sf.банк.РежимТекущ().Режим() == "" {
		sf.checkBankMode()
	}
	sf.checkBankTime() // Проверка времени ожидания
	countTime := sf.банк.ВремяОпрос().Получ()
	if countTime > 5 {
		return nil
	}
	sf.checkBankForce() // Нужно ли ускорить апгрейд банка
	if sf.банк.РежимТекущ().Получ() == "upgrade" {
		return nil
	}
	sf.checkBankTake()    // Нужно ли забрать банк
	sf.checkBankProduct() // Запуск производства в  банке
	return nil
}

// Проверяет режим работы банка
func (sf *База) checkBankMode() {
	var (
		strOut  string
		isFind  bool
		lstBase = sf.СписПолучить()
	)
	for _, strOut = range lstBase {
		if strings.Contains(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`) {
			isFind = true
			break
		}
	}
	if !isFind {
		return
	}
	lstSilver := strings.Split(strOut, `<td class="vam"><div class="nwr pr5 gray1"><img class="rico vm" src="/images/icons/silver.png?2" alt="silver"/>&nbsp;`)
	strSilver := lstSilver[1]
	lstSilver = strings.Split(strSilver, `</div></td>`)
	strSilver = "Серебро-" + lstSilver[0]
	sf.банк.РежимТекущ().РежимУст(strSilver)

}

// Проверяет на время ожидания банка
func (sf *База) checkBankTime() {
	var (
		strOut  string
		ind     int
		isFind  bool
		lstBase = sf.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `Производит серебро<br/>`) {
			isFind = true
			ind += 10
			strOut = lstBase[ind]
			break
		}
	}
	if !isFind {
		return
	}
	if !strings.Contains(strOut, `<td><div class="value-block lh1"><span><span>`) {
		return
	}
	lstTime := strings.Split(strOut, `<td><div class="value-block lh1"><span><span>`)
	strTime := lstTime[1]
	lstTime = strings.Split(strTime, `</span></span></div></td>`)
	strTime = lstTime[0]
	if err := sf.банк.ParseCountDown(strTime); err != nil {
		log.Printf("ERRO Base.checkBankTime(): при установке времени ожидания банка(%v)\n\terr=%v\n", strTime, err)
	}
}

// Проверяет на произвести в банке
func (sf *База) checkBankProduct() {
	var (
		strOut  string
		ind     int
		isFind  bool
		lstBase = sf.СписПолучить()
	)
	for ind, strOut = range lstBase {
		if strings.Contains(strOut, `Производит серебро<br/>`) {
			isFind = true
			ind += 11
			strOut = lstBase[ind]
			break
		}
	}
	if !isFind {
		return
	}
	if !strings.Contains(strOut, `>Производство</span>`) {
		return
	}
	sf.банк.UpdateLst()
	sf.банк.SetCountDown(1)
}

// Проверка получения серебра из банка
func (sf *База) checkBankTake() {
	var (
		ind     int
		strOut  string
		isFind  bool
		lstBank = sf.СписПолучить()
		strLink string
	)
	for ind, strOut = range lstBank {
		if strings.Contains(strOut, `<span class="green2">Банк - `) {
			ind += 18
			strLink = lstBank[ind]
			isFind = true
			break
		}
	}
	if !isFind {
		return
	}
	if !strings.Contains(strLink, `"><span><span>Забрать</span></span></a>`) {
		return
	}
	lstLink := strings.Split(strLink, `<a class="simple-but border" href="`)
	strLink = lstLink[1]
	lstLink = strings.Split(strLink, `"><span><span>Забрать</span></span></a>`)
	strLink = "https://wartank.ru/" + lstLink[0]
	lstBank, err := sf.сеть.Get(strLink)
	if err != nil {
		// log._rintf("ERRO Base.checkBankTake(): при выполнении GET-запроса 'забрать серебро', err=\n\t%v\n", err)
		return
	}
	sound.BankTake()
	isFind = false
	for _, strOut = range lstBank { // Проверка на производство в банке
		if strings.Contains(strOut, `<title>Производство</title>`) {
			isFind = true
			break
		}
	}
	if isFind {
		if err := sf.банк.СтрОбновить(lstBank); err != nil {
			log.Printf("ERRO Base.checkBankTake(): при установке lstBank, err=\n\t%v'n", err)
		}
		sf.банк.SetCountDown(1)
		return
	}
	if err := sf.СтрОбновить(lstBank); err != nil {
		log.Printf("ERRO Base.checkBankTake(): при установке lstBase, err=\n\t%v'n", err)
	}
	sf.банк.SetCountDown(1)
}

// Проверяет на ускорение апгрейда банка
func (sf *База) checkBankForce() {
	var (
		ind     int
		strOut  = ""
		isOut   bool
		lstBase = sf.СписПолучить()
	)
	{ // Проверка на платное ускорение апгрейда
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит серебро<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `Ускорить за`) {
			if err := sf.банк.SetCountDown(времОжидПлат); err != nil {
				log.Printf("WARN Base.checkBankForce(): при установке времени ожидания платного ускорения апгрейда банка(%v)\n\terr=%v\n", времОжидПлат, err)
			}
			sf.банк.РежимТекущ().Уст("upgrade")
			sf.банк.РежимТекущ().РежимУст("апгрейд")
			return
		}
	}
	{ // Проверка на бесплатное ускорение апгрейда
		isOut = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит серебро<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `>Ускорение<`) {

			lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
			strLink := lstLink[1]
			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
			strLink = "https://wartank.ru/" + lstLink[0]
			lstBase, err := sf.сеть.Get(strLink)
			if err != nil {
				// log._rintf("ERRO NetBank.checkBankForce(): при GET-запросе на бесплатном ускорении апгрейда банка, err=\n\t%v\n", err)
				return
			}
			if err := sf.СтрОбновить(lstBase); err != nil {
				// log._rintf("ERRO NetBank.checkBankForce(): при обновлении lstBase, err=\n\t%v\n", err)
				return
			}
			sf.банк.РежимТекущ().Уст("upgrade")
			sf.банк.РежимТекущ().РежимУст("апгрейд")
			if err := sf.банк.SetCountDown(времОжидБесплат); err != nil {
				log.Printf("WARN Base.checkBankForce(): при установке времени бесплатного ускорения агрейда банка(%v)\n\terr=%v\n", времОжидБесплат, err)
			}
		}
	}
}

// Проверяет на ускорение апгрейда шахты
func (sf *База) шахтаАпгрейдФорсаж() {
	var (
		ind     int
		strOut  = ""
		isOut   bool
		lstBase = sf.СписПолучить()
	)
	{ // Проверка на платное ускорение апгрейда
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит ресурсы<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `Ускорить за`) {
			sf.шахта.РежимТекущ().Уст("upgrade")
			sf.шахта.РежимТекущ().РежимУст("апгрейд")
			if err := sf.шахта.SetCountDown(времОжидПлат); err != nil {
				log.Printf("WARN Base.checkMineForce(): при установке времени платного апгрейда шахты(%v)\n\terr=%v\n", времОжидПлат, err)
			}
			return
		}
	}
	{ // Проверка на время бесплатного ускорение апгрейда
		isOut = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит ресурсы<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `>Ускорение<`) {
			lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
			strLink := lstLink[1]
			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
			strLink = "https://wartank.ru/" + lstLink[0]
			lstBase, err := sf.сеть.Get(strLink)
			if err != nil {
				// log._rintf("ERRO NetBank.checkMineForce(): при GET-запросе на бесплатном ускорении апгрейда шахты, err=\n\t%v\n", err)
				return
			}
			if err := sf.СтрОбновить(lstBase); err != nil {
				// log._rintf("ERRO NetBank.checkMineForce(): при обновлении lstBase, err=\n\t%v\n", err)
				return
			}
			if err := sf.шахта.SetCountDown(времОжидБесплат); err != nil {
				log.Printf("WARN Base.checkMineForce(): при установке времени апгрейда шахты(%v)\n\terr=%v\n", времОжидБесплат, err)
			}
			// sound.MineForce()
			sf.шахта.РежимТекущ().Уст("upgrade")
			sf.шахта.РежимТекущ().РежимУст("апгрейд")
			return
		}
	}
	// Все проверки прошли -- это просто работа
	sf.шахта.РежимТекущ().Уст("work")
}

// Проверяет на ускорение апгрейда полигона
func (sf *База) проверитьПолигонУсиление() {
	var (
		ind     int
		strOut  = ""
		isOut   bool
		lstBase = sf.СписПолучить()
	)
	countTime := sf.полигон.ВремяОпрос().Получ()
	if countTime > 3 {
		return
	}
	{ // Проверка на платное ускорение апгрейда
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит усиление танка<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 29
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `Ускорить за`) {
			// strTime := lstBase[ind-21]
			// lstTime := strings.Split(strTime, `<td><div class="value-block lh1"><span><span>`)
			// strTime = lstTime[1]
			// lstTime = strings.Split(strTime, `</span></span></div></td>`)
			// strTime = lstTime[0]
			// if err := sf.polygon.CountDown().Set(strTime); err != nil {
			// 	// log._rintf("WARN Base.checkMineForce(): при установке времени апгрейда полигона(%v)\n\terr=%v\n", strTime, err)
			// }
			sf.полигон.РежимТекущ().Уст("upgrade")
			sf.полигон.РежимТекущ().РежимУст("апгрейд")
			if err := sf.полигон.SetCountDown(времОжидПлат); err != nil {
				log.Printf("WARN Base.checkPolygonForce(): при установке платного времени апгрейда полигона(%v)\n\terr=%v\n", времОжидПлат, err)
			}
			return
		}
	}
	{ // Проверка на бесплатное ускорение апгрейда
		isOut = false
		for ind, strOut = range lstBase {
			if strings.Contains(strOut, `Производит усиление танка<br/>`) {
				// Убедиться что есть строка платного ускорения
				isOut = true
				ind += 26
				strOut = lstBase[ind]
				break
			}
		}
		if isOut && strings.Contains(strOut, `>Ускорение<`) {
			lstLink := strings.Split(strOut, `<td style="width:50%;padding-left:1px;"><a class="simple-but border" href="`)
			strLink := lstLink[1]
			lstLink = strings.Split(strLink, `"><span><span>Ускорение</span></span></a>`)
			strLink = "https://wartank.ru/" + lstLink[0]
			lstBase, err := sf.сеть.Get(strLink)
			if err != nil {
				// log._rintf("ERRO NetBank.checkPolygonForce(): при GET-запросе на бесплатном ускорении апгрейда полигона, err=\n\t%v\n", err)
				return
			}
			if err := sf.СтрОбновить(lstBase); err != nil {
				// log._rintf("ERRO NetBank.checkPolygonForce(): при обновлении lstBase, err=\n\t%v\n", err)
				return
			}
			// sound.MineForce()
			sf.полигон.РежимТекущ().Уст("upgrade")
			sf.полигон.РежимТекущ().РежимУст("апгрейд")
			// Установить время ожидания для обновления
			if err := sf.полигон.SetCountDown(времОжидБесплат); err != nil {
				log.Printf("WARN Base.checkPolygonForce(): при установке времени бесплатного апгрейда полигона(%v)\n\terr=%v\n", времОжидБесплат, err)
			}
			// log._rintf("INFO NetBank.checkPolygonForce(): ускорено строительство полигона\n")
			return
		}
	}
	// Все проверки прошли -- это просто работа
	sf.полигон.РежимТекущ().Уст("work")
}