import network, { NetworkResponse } from '@system.network';
import { connection } from '@kit.NetworkKit';
import { xNetworkType } from "../interface"
import radio from '@ohos.telephony.radio'
import { Emitter, onNativePageReady } from '@dcloudio/uni-runtime';
import { BusinessError } from "@kit.BasicServicesKit";

export type OnNetworkStatusChangeCallbackResult = {
	/**
	 * 当前是否有网络连接
	 * @type boolean
	 */
	isConnected : boolean,
	/**
	 * 网络类型
	 */
	networkType : string
};
export type OnNetworkStatusChangeCallback = (result : OnNetworkStatusChangeCallbackResult) => void;
export type OnNetworkStatusChange = (callback : OnNetworkStatusChangeCallback) => void;
export type OffNetworkStatusChange = (callback : (result : any) => void) => void;


interface IUniGetNetworkTypeEventEmitter {
	on : (eventName : string, callback : Function) => void
	once : (eventName : string, callback : Function) => void
	off : (eventName : string, callback ?: Function) => void
	emit : (eventName : string, ...args : (Object | undefined | null)[]) => void
}
const UniGetNetworkTypeEventEmitter = new Emitter() as IUniGetNetworkTypeEventEmitter
function networkGetType() {
	return new Promise<number>((resolve, reject) => {
		try {
			radio.getPrimarySlotId()
				.then((slotId : number) => radio.getSignalInformationSync(slotId))
				.then((signalInformation : Array<radio.SignalInformation>) => {
					const data = signalInformation[0]
					if (data && data.signalType) {
						resolve(signalType(data.signalType))
					} else {
						resolve(NetworkinfoType.NONE)
					}
				})
		} catch (error) {
			reject(error as BusinessError)
		}
	})
}

enum NetworkinfoType {
	// 网络连接状态未知
	UNKNOW = 0,
	// 未连接网络
	NONE = 1,
	// 有线网络
	ETHERNET = 2,
	// 无线WIFI网络
	WIFI = 3,

	"2G" = 4,
	"3G" = 5,
	"4G" = 6,
	"5G" = 7,
}


function signalType(resultObj : radio.NetworkType) : number {
	switch (resultObj) {
		case radio.NetworkType.NETWORK_TYPE_GSM:
		case radio.NetworkType.NETWORK_TYPE_CDMA:
			return NetworkinfoType['2G']
		case radio.NetworkType.NETWORK_TYPE_WCDMA:
		case radio.NetworkType.NETWORK_TYPE_TDSCDMA:
			return NetworkinfoType['3G']
		case radio.NetworkType.NETWORK_TYPE_LTE:
			return NetworkinfoType['4G']
		case radio.NetworkType.NETWORK_TYPE_NR:
			return NetworkinfoType['5G']
		case radio.NetworkType.NETWORK_TYPE_UNKNOWN:
			return NetworkinfoType.UNKNOW
		default:
			return NetworkinfoType.NONE
	}
}

// 构造单例对象
class GlobalContext {
	public netList : connection.NetHandle[] = [];
	public netHandle : connection.NetHandle | null = null;
	private constructor() { }
	private static instance : GlobalContext;

	public static getContext() : GlobalContext {
		if (!GlobalContext.instance) {
			GlobalContext.instance = new GlobalContext();
		}
		return GlobalContext.instance;
	}
}


//当前是否有网络。
export function isNetworkAvailable() : Promise<boolean> {
	return new Promise((resolve) => {
		try {
			radio.getPrimarySlotId()
				.then((slotId : number) => radio.getSignalInformationSync(slotId))
				.then((signalInformation : Array<radio.SignalInformation>) => {
					const data = signalInformation[0]
					if (data && data.signalType) {
						resolve(signalType(data.signalType) != NetworkinfoType.NONE)
					} else {
						resolve(false)
					}
				})
		} catch (error) {
			resolve(false)
		}
	})
}

export function getNetworkType() : Promise<xNetworkType | null> {
	return new Promise((resolve, reject) => {
		try {
			// 调用getDefaultNet方法，获取默认的数据网络(NetHandle)
			connection.getDefaultNet().then((data : connection.NetHandle) => {
				if (data) {
					GlobalContext.getContext().netHandle = data;
					// 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息
					connection.getNetCapabilities(GlobalContext.getContext().netHandle!).then((data : connection.NetCapabilities) => {
						// 获取网络类型(bearerTypes)
						const bearerTypes : Set<number> = new Set(data.bearerTypes);
						const bearerTypesNum = Array.from(bearerTypes.values());
						for (const item of bearerTypesNum) {
							if (item == connection.NetBearType.BEARER_CELLULAR) {
								// 蜂窝网
								networkGetType().then(() => {
									resolve('Mobile')
								}).catch(reject)
							} else if (item == connection.NetBearType.BEARER_WIFI) {
								// Wi-Fi网络
								resolve('WiFi')
							} else if (item == connection.NetBearType.BEARER_ETHERNET) {
								// 以太网网络
								resolve('WiredNetwork')
							} else {
								resolve('Other')
							}
						}
					}).catch((err : BusinessError) => {
						reject(err)
					})
				}
			})
		} catch (error) {
			reject(null)
		}

	})
}

function invokeOnNetworkStatusChange(networkType : string) {
	// UniGetNetworkTypeEventEmitter.emit(
	// 	'networkStatusChange',
	// 	{
	// 		isConnected: networkType !== NetworkinfoType[1],
	// 		networkType: networkType.toLocaleLowerCase(),
	// 	} as OnNetworkStatusChangeCallbackResult
	// )
	
	UniGetNetworkTypeEventEmitter.emit('networkStatusChange',networkType !== NetworkinfoType[1])
}

function getCurrentType() {
	return new Promise<number>((resolve, reject) => {
		// 调用getDefaultNet方法，获取默认的数据网络(NetHandle)
		connection.getDefaultNet().then((data : connection.NetHandle) => {
			if (data) {
				GlobalContext.getContext().netHandle = data;
				// 获取netHandle对应网络的能力信息。能力信息包含了网络类型、网络具体能力等网络信息
				connection.getNetCapabilities(GlobalContext.getContext().netHandle!).then((data : connection.NetCapabilities) => {
					// 获取网络类型(bearerTypes)
					const bearerTypes : Set<number> = new Set(data.bearerTypes);
					const bearerTypesNum = Array.from(bearerTypes.values());
					for (const item of bearerTypesNum) {
						if (item == connection.NetBearType.BEARER_CELLULAR) {
							// 蜂窝网
							networkGetType().then(resolve).catch(reject)
						} else if (item == connection.NetBearType.BEARER_WIFI) {
							// Wi-Fi网络
							resolve(NetworkinfoType.WIFI)
						} else if (item == connection.NetBearType.BEARER_ETHERNET) {
							// 以太网网络
							resolve(NetworkinfoType.ETHERNET)
						} else {
							resolve(NetworkinfoType.UNKNOW)
						}
					}
				}).catch((err : BusinessError) => {
					reject(err)
				})
			}
		})
	})
}



class Network {
	static netConnection : connection.NetConnection | null = null

	constructor() {
		Network.netConnection = connection.createNetConnection()
	}

	static ohoSubscribe() {
		if (!Network.netConnection) {
			Network.netConnection = connection.createNetConnection()
		}

		if (Network.netConnection) {

			Network.netConnection.register((err : BusinessError) => { })
			Network.netConnection.on('netCapabilitiesChange', (capability : connection.NetCapabilityInfo) => {
				const NetBearType = capability?.netCap?.bearerTypes[0]
				let networkType = ''
				switch (NetBearType) {
					case connection.NetBearType.BEARER_CELLULAR:
						getCurrentType().then((type : number) => {
							invokeOnNetworkStatusChange(NetworkinfoType[type])
						}).catch(() => {
							invokeOnNetworkStatusChange(NetworkinfoType[1])
						})
						return
					case connection.NetBearType.BEARER_WIFI:
						networkType = NetworkinfoType[3]
						break
					case connection.NetBearType.BEARER_ETHERNET:
						networkType = NetworkinfoType[2]
						break
					/* case connection.NetBearType.BEARER_VPN:
					  networkType = 'vpn'
					  break */
					default:
						networkType = NetworkinfoType[1]
				}
				invokeOnNetworkStatusChange(networkType)
				
			})
			Network.netConnection.on('netLost', (netLost : connection.NetHandle) => {
				invokeOnNetworkStatusChange(NetworkinfoType[1])
			})
		}
	}
}

new Network()

type CallType = (conecting : boolean) => void;
let call : CallType = (conecting : boolean) => { }
export const xNetChange = (callback : CallType) => {
	call = callback;
	UniGetNetworkTypeEventEmitter.on('networkStatusChange', call)
}
//取消监听
export function xUnNetChange() {
	UniGetNetworkTypeEventEmitter.off('networkStatusChange', call)
}

onNativePageReady().then(() => {
	Network.ohoSubscribe()
})