/*
 * @Descripttion:
 * @version:
 * @Author: pengming
 * @Date: 2023-10-26 17:54:32
 * @LastEditors: pengming
 */
#include "ScannerManager.h"
#include "usb_manager.h"
#include "G1G2Scanner.h"
#include "taskinfo.h"
using namespace std;
//#include <snowflake.h>

#define _countof(a) (sizeof(a) / sizeof((a)[0]))

static DevInfo g_sup_devs[] = {
	{0x3072,0x0139,"00:00:00:00:00:00","G100-3399",&ScannerManager::create_scanner_g1g2},
	{0x3072,0x0239,"00:00:00:00:00:00","G200-3399",&ScannerManager::create_scanner_g1g2}
};


std::string get_date_time()
{
	time_t now_time;
	struct tm* info_t;
	char buffer[32];
	time(&now_time);
	info_t = localtime(&now_time);
	strftime(buffer, 32, "%Y-%m-%d %H:%M:%S", info_t);
	std::string str = buffer;
	return str;
}
ScannerManager::ScannerManager()
{
}

ScannerManager::~ScannerManager()
{
	usb_manager::clear();
}

void ScannerManager::Init()
{
	usb_manager::instance()->register_hotplug(&ScannerManager::usb_event_handle, this);
}

void ScannerManager::SetScannerEventCallback(scanner_event_handler event_handler, void* user)
{
	m_event_handler = event_handler;
	m_user = user;
}

std::vector<ScannerManager::OLSCANNER> ScannerManager::GetOnlineScanners()
{
	return m_onlinescanners;
}

int ScannerManager::SetCurrentDevice(int dev_idx)
{
	lock_guard<mutex> m_lock(m_mtx_mgr);
	if (dev_idx > (m_onlinescanners.size() - 1))
	{
		return 0;
	}
	m_current_select_idx = dev_idx;
	m_cur_scanner = static_cast<std::shared_ptr<IScanner>>(m_onlinescanners[dev_idx].scanner);
	return 1;
}

std::vector<TaskInfo> ScannerManager::GetCurSupTests()
{
	return m_onlinescanners[m_current_select_idx].taskinfos;
}

void ScannerManager::AddTask(int taskID)
{
	TASKID id = (TASKID)taskID;
	if (id >= TASK_ID_NUM || taskID < 0)
		return;

	if (m_cur_scanner.get())
	{
		switch (id)
		{
		case TASK_ID_CHECK_OUTLOOK:
			break;
		case TASK_ID_CHECK_MECHANICAL_PRP:
			break;
		case TASK_ID_CKECK_ASSEMBLE:
			break;
		case TASK_ID_CHECK_POWERSUPPLY:
			break;
		case TASK_ID_CHECK_PWRBTN:
			break;
		case TASK_ID_CHECK_RESET_RECOVERY_BTN:
			break;
		case TASK_ID_CHECK_SWITCHS:
		{
			auto ret = m_cur_scanner->CheckSwitchs(1, 1, 1, 1);
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_SWITCHS].result = ret ? "PASS" : "NG";
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_SWITCHS].tested = "True";
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_SWITCHS].datetime = get_date_time();
			break;
		}
		case TASK_ID_CHECK_IMGS:
			m_cur_scanner->Flat(0);
			break;
		case TASK_ID_CHECK_HW_CAPACITY:
		{
			auto ret = m_cur_scanner->CheckCapacity(0xc0000000, 0xA00000);//3GB  10GB
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_HW_CAPACITY].result = ret?"PASS":"NG";
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_HW_CAPACITY].tested = "True";
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_HW_CAPACITY].datetime = get_date_time();

		}
		break;
		case TASK_ID_CHECK_DISPLAY:
		{
			m_cur_scanner->CheckLEDDisplay("");//3GB  10GB
			m_onlinescanners[m_current_select_idx].taskinfos[TASK_ID_CHECK_DISPLAY].tested = "True";
		}
		break;
		default:
			break;
		}
	}

}

bool ScannerManager::UpdateTaskResult(int taskID, std::string result)
{
	bool ret = false;
	if (m_current_select_idx < m_onlinescanners.size() &&
		m_onlinescanners[m_current_select_idx].scanner.get())
	{
		for (auto info = m_onlinescanners[m_current_select_idx].taskinfos.begin(); info != m_onlinescanners[m_current_select_idx].taskinfos.end(); info++)
		{
			if (info->id == taskID)
			{
				info->result = result;
				info->tested = "True";
				info->datetime = get_date_time();
				ret = true;
				break;
			}
		}
	}
	return ret;
}

void ScannerManager::FinishTest()
{
	if (m_cur_scanner.get())
	{
		auto content = js_task.GetInfosDump(m_onlinescanners[m_current_select_idx].taskinfos);
		m_cur_scanner->RecordFinalResult(content);
	}

}

void ScannerManager::Reboot(bool b_loader)
{
	if (m_cur_scanner.get())
		m_cur_scanner->Reboot(b_loader);
}

void ScannerManager::PowerOFF()
{
	if (m_cur_scanner.get())
		m_cur_scanner->PowerOFF();
}

void ScannerManager::usb_event_handle(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry, void* user)
{
	ScannerManager* This = (ScannerManager*)user;

	This->on_hgscanner_pnp(ev, device, vid, pid, usb_ver_h, usb_ver_l, retry);
}

void ScannerManager::on_scanner_handler(unsigned int evt, int data_type, unsigned int data_len, void* data, void* user)
{
	ScannerManager* This = (ScannerManager*)user;
	This->on_scanner_call(evt, data_type, data_len, data);
}

void ScannerManager::on_hgscanner_pnp(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry)
{
	DevEvent devevent;
	devevent.Vid = vid;
	devevent.Pid = pid;
	if (ev == USB_EVENT_DEVICE_ARRIVED)
	{
		int aa = _countof(g_sup_devs);
		for (int i = 0; i < _countof(g_sup_devs); ++i)
		{
			if (g_sup_devs[i].vid == vid && g_sup_devs[i].pid == pid)
			{
				int aa = 1;
				usb_io* io = NULL;
				usb_manager::instance()->open(device, &io);
				void* handler = nullptr;
				auto iscanner = g_sup_devs[i].create_scanner(g_sup_devs[i].type.c_str(), io, handler);
				if (iscanner.get())
				{
					OLSCANNER olscanner;
					olscanner.dev = device;
					olscanner.display_name = g_sup_devs[i].type;
					olscanner.ind = m_onlinescanners.size();//��0��ʼ����
					olscanner.scanner = iscanner;
					GetDefaultTaskinfos(olscanner.taskinfos);
					olscanner.scanner->SetScannerCallback(&ScannerManager::on_scanner_handler, this);
					libusb_ref_device(device);   //  ref the device of queue online_devices_
					m_onlinescanners.push_back(olscanner);
					devevent.EvtCode = USB_EVENT_DEVICE_ARRIVED;
					devevent.Msg = g_sup_devs[i].type;
					devevent.Index = olscanner.ind;
					m_event_handler(devevent, 0, 0, 0,0, nullptr, m_user);
				}
			}
		}
	}
	else if (ev == USB_EVENT_DEVICE_LEFT)
	{
		devevent.EvtCode = USB_EVENT_DEVICE_LEFT;
		std::vector<OLSCANNER>::iterator it = std::find(m_onlinescanners.begin(), m_onlinescanners.end(), device);
		if (it != m_onlinescanners.end())
		{
			if (it->scanner)
			{
				devevent.Index = it->ind;
				m_event_handler(devevent, 0, 0, 0, 0,nullptr, m_user);
				it->scanner->USBDisconnect();
				libusb_unref_device(it->dev);   // unref the device of queue online_devices_
				m_onlinescanners.erase(it);
			}
		}
	}
}

void ScannerManager::on_scanner_call(unsigned int evt, int data_type, unsigned int data_len, void* data)
{
	DevEvent info;
	info.Msg = m_onlinescanners[m_current_select_idx].display_name;
	info.EvtCode = evt;
	m_event_handler(info,1, evt, data_type, data_len, data, m_user);
}

void ScannerManager::GetDefaultTaskinfos(std::vector<TaskInfo>& infos)
{
	infos = js_task.GetInfos("info.json");
}

std::shared_ptr<IScanner> ScannerManager::create_scanner_g1g2(const char* name, usb_io* io, void* h)
{
	std::shared_ptr<IScanner> m_g1g2scanner;
	m_g1g2scanner.reset(new G1G2Scanner(io));

	return m_g1g2scanner;
}