package discoverer

import (
	"net"
	"regexp"
	"strings"

	occu "git.loafle.net/overflow/commons-go/core/util"
	ocmd "git.loafle.net/overflow/commons-go/model/discovery"
)

func scanZone(dz *ocmd.DiscoverZone, resultChan chan interface{}, errChan chan error, doneChan chan<- struct{}, stopChan chan struct{}) {
	defer func() {
		doneChan <- struct{}{}
	}()

	var err error
	var ifaces []net.Interface
	var addrs []net.Addr
	var ipnet *net.IPNet
	var zones []*net.IPNet
	// var gwIP net.IP
	// var gwIFace string

	// if gwIP, gwIFace, err = gateway.DiscoverGateway(); nil != err {
	// 	logChan <- err
	// 	return
	// }

	if ifaces, err = net.Interfaces(); nil != err {
		errChan <- err
		return
	}

	zones = make([]*net.IPNet, 0)

	for _, i := range ifaces {

		if addrs, err = i.Addrs(); nil != err {
			errChan <- err
			continue
		}

		for _, addr := range addrs {

			if _, ipnet, err = net.ParseCIDR(addr.String()); nil != err {
				errChan <- err
				continue
			}
			if ipnet.IP.IsLoopback() || checkSameZone(zones, ipnet) || checkExclude(dz.ExcludePatterns, i.Name) {
				continue
			}

			zones = append(zones, ipnet)

			z := &ocmd.Zone{
				Network:        ipnet.String(),
				Iface:          i.Name,
				Mac:            i.HardwareAddr.String(),
				IPV4:           strings.Split(addr.String(), "/")[0],
				DiscoveredDate: occu.NowPtr(),
			}

			resultChan <- z
		}
	}
}

func checkExclude(ep []string, iface string) bool {
	var r *regexp.Regexp
	var err error
	for _, p := range ep {
		if r, err = regexp.Compile(p); nil != err {
			return false
		}
		if r.MatchString(iface) {
			return true
		}
	}
	return false
}

func checkSameZone(zones []*net.IPNet, ipnet *net.IPNet) bool {
	for _, i := range zones {
		if i.Contains(ipnet.IP) {
			return true
		}
	}
	return false
}