package iploc

import (
	_ "embed"
	"encoding/binary"
	"net"

	"github.com/yinheli/mahonia"
)

// Note: This file is a modified version of https://github.com/yinheli/qqwry.

//go:embed qqwry.dat
var qqwry []byte

const (
	cIndexLen      = 7
	cRedirectMode1 = 0x01
	cRedirectMode2 = 0x02
)

// Find get country and city base ip
func Find(ip string) (string, string) {
	offset := searchIndex(binary.BigEndian.Uint32(net.ParseIP(ip).To4()))
	if offset <= 0 {
		return "", ""
	}
	var country, area []byte
	mode := readMode(offset + 4)
	if mode == cRedirectMode1 {
		countryOffset := readUInt24(offset + 5)
		mode = readMode(countryOffset)
		if mode == cRedirectMode2 {
			c := readUInt24(countryOffset + 1)
			country = readString(c)
			countryOffset += 4
		} else {
			country = readString(countryOffset)
			countryOffset += uint32(len(country) + 1)
		}
		area = readArea(countryOffset)
	} else if mode == cRedirectMode2 {
		countryOffset := readUInt24(offset + 5)
		country = readString(countryOffset)
		area = readArea(offset + 8)
	} else {
		country = readString(offset + 4)
		area = readArea(offset + uint32(5+len(country)))
	}
	enc := mahonia.NewDecoder("gbk")
	Country := enc.ConvertString(string(country))
	City := enc.ConvertString(string(area))
	return Country, City
}

func readMode(offset uint32) byte {
	return qqwry[offset]
}

func readArea(offset uint32) []byte {
	mode := readMode(offset)
	if mode == cRedirectMode1 || mode == cRedirectMode2 {
		areaOffset := readUInt24(offset + 1)
		if areaOffset == 0 {
			return []byte("")
		} else {
			return readString(areaOffset)
		}
	} else {
		return readString(offset)
	}
}

func readString(offset uint32) []byte {
	data := make([]byte, 0, 30)
	for {
		if qqwry[offset] == 0 {
			break
		}
		data = append(data, qqwry[offset])
		offset++
	}
	return data
}

func searchIndex(ip uint32) uint32 {
	header := qqwry[:8]
	start := binary.LittleEndian.Uint32(header[:4])
	end := binary.LittleEndian.Uint32(header[4:])
	for {
		mid := getMiddleOffset(start, end)
		buf := qqwry[mid : mid+cIndexLen]
		ipaddr := binary.LittleEndian.Uint32(buf[:4])
		if end-start == cIndexLen {
			offset := byte3ToUInt32(buf[4:])
			// TODO: 这里可能有bug，需要优化
			if ip < binary.LittleEndian.Uint32(qqwry[end:end+4]) {
				return offset
			} else {
				return 0
			}
		}
		// 找到的比较大，向前移
		if ipaddr > ip {
			end = mid
		} else if ipaddr < ip { // 找到的比较小，向后移
			start = mid
		} else {
			return byte3ToUInt32(buf[4:])
		}
	}
}

func readUInt24(offset uint32) uint32 {
	return byte3ToUInt32(qqwry[offset : offset+3])
}

func getMiddleOffset(start uint32, end uint32) uint32 {
	records := ((end - start) / cIndexLen) >> 1
	return start + records*cIndexLen
}

func byte3ToUInt32(data []byte) uint32 {
	i := uint32(data[0]) & 0xff
	i |= (uint32(data[1]) << 8) & 0xff00
	i |= (uint32(data[2]) << 16) & 0xff0000
	return i
}