package main

import (
	"bufio"
	"flag"
	"log"
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

type FileInfo struct {
	FileName string
	FilePath string
	FileSize int64
	//ModTime  string
}

var (
	dbg                bool   = false
	aodType            string = ""
	aodPath            string = ""
	modPath            string = ""
	aodInfoList        []FileInfo
	moduleInfoList     []FileInfo
	criList            = make([]string, 0)
	moduleList         = make([]string, 0)
	distinctCriList    = make([]string, 0)
	distinctModuleList = make([]string, 0)
	needlessModuleList = make([]string, 0)
	missingModuleList  = make([]string, 0)
	errAOD             = make([]string, 0)
	errCRI             = make([]string, 0)
)

var regFilter = `.*`
var regLNB = `(?i)\S{10,}\.[0-9]{3}`
var regTNB = `(?i)SSW\S{7}\.SSW\S{7}`
var regSBID = `(?i)\S{8,}\.DAT`

func init() {
	flag.BoolVar(&dbg, "v", false, "Show Verbose Debug Messages")
	flag.StringVar(&aodPath, "a", `D:\MfgTest\PRELOAD\AOD`, "Path Of AODs")
	flag.StringVar(&modPath, "m", `D:\Common`, "Path Of Modules")
	flag.StringVar(&aodType, "t", "*", "Type Of AODs, LNB/TNB/SBID/*")
	flag.Parse()
}

func main() {
	_, err := os.Stat(aodPath)
	if err != nil {
		log.Printf("[ERR]  Path Of AODs Not Exists.\r\n")
		os.Exit(1)
	}
	_, err = os.Stat(modPath)
	if err != nil {
		log.Printf("[ERR]  Path Of Modules Not Exists.\r\n")
		os.Exit(1)
	}

	log.Printf("[MSG]  Summary Loacal AODs ...\r\n")
	aodInfoList, err = _SummaryAOD(aodPath, aodType)
	if err != nil {
		log.Printf("[ERR]  Get AOD List Failed: %s\r\n", err.Error())
		os.Exit(1)
	}
	log.Printf("[MSG]  Total Local AODs: %d\r\n", len(aodInfoList))

	log.Printf("[MSG]  Summary Local Modules ...\r\n")
	moduleInfoList, err = _SummaryFiles(modPath)
	if err != nil {
		log.Printf("[ERR]  Get Module List Failed: %s\r\n", err.Error())
		os.Exit(1)
	}
	log.Printf("[MSG]  Total Local Modules: %d\r\n", len(moduleInfoList))

	regCRI, err := regexp.Compile(`(?i).*File=(.{1,}.CRI)`)
	if err != nil {
		log.Printf("[ERR]  RegExp - CRI Compile Error: %s\r\n", err.Error())
		os.Exit(1)
	}
	log.Printf("[MSG]  Summary CRIs From AODs ...\r\n")
	for _, aod := range aodInfoList {
		rdr, err := os.Open(aod.FilePath)
		if err != nil {
			errAOD = append(errAOD, aod.FilePath)
		}
		buf := bufio.NewScanner(rdr)
		for buf.Scan() {
			if buf.Err() != nil {
				break
			}
			rst := regCRI.FindStringSubmatch(buf.Text())
			if len(rst) != 2 {
				continue
			}
			criList = append(criList, strings.TrimSpace(rst[1]))
		}
	}
	log.Printf("[MSG]  Total CRIs From AODs: %d\r\n", len(criList))
	distinctCriList = _RemoveDuplicateElementOfSlice(criList)
	log.Printf("[MSG]  Distinct CRIs From AODs: %d\r\n", len(distinctCriList))

	regModuleName, err := regexp.Compile(`(?i)(ModuleName[0-9]{0,}|ModuleThis[0-9]{0,})=(.{1,})`)
	if err != nil {
		log.Printf("[ERR]  RegExp - ModuleName Compile Error: %s\r\n", err.Error())
		os.Exit(1)
	}
	log.Printf("[MSG]  Summary Modules From CRIs ...\r\n")
	for _, cri := range distinctCriList {
		rdr, err := os.Open(modPath + "\\" + cri)
		if err != nil {
			errCRI = append(errCRI, modPath+"\\"+cri)
		}
		buf := bufio.NewScanner(rdr)
		for buf.Scan() {
			if buf.Err() != nil {
				break
			}
			rst := regModuleName.FindStringSubmatch(buf.Text())
			if len(rst) != 3 {
				continue
			}
			moduleList = append(moduleList, strings.TrimSpace(rst[2]))
		}
	}
	log.Printf("[MSG]  Total Modules From CRIs: %d\r\n", len(moduleList))
	distinctModuleList = _RemoveDuplicateElementOfSlice(moduleList)
	log.Printf("[MSG]  Distinct Modules From CRIs: %d\r\n", len(distinctModuleList))

	log.Printf("[MSG]  Checking Missing Modules ...\r\n")
	for _, m := range distinctModuleList {
		exist := false
		for _, l := range moduleInfoList {
			if strings.EqualFold(m, l.FileName) {
				exist = true
				break
			}
		}
		if !exist {
			missingModuleList = append(missingModuleList, m)
		}
	}

	log.Printf("[MSG]  Checking Needless Modules ...\r\n")
	for _, l := range moduleInfoList {
		needless := true
		for _, m := range distinctModuleList {
			if strings.EqualFold(l.FileName, m) {
				needless = false
				break
			}
		}
		if needless {
			needlessModuleList = append(needlessModuleList, l.FileName)
		}
	}

	log.Printf("*****  Error AODs: %d\r\n", len(errAOD))
	_WriteFileFromStringSlice(".\\errAOD.txt", errAOD)

	log.Printf("*****  Error CRIs: %d\r\n", len(errCRI))
	_WriteFileFromStringSlice(".\\errCRI.txt", errCRI)

	log.Printf("#####  Missing Modules: %d\r\n", len(missingModuleList))
	_WriteFileFromStringSlice(".\\MissingModules.txt", missingModuleList)

	log.Printf("#####  Needless Modules: %d\r\n", len(needlessModuleList))
	_WriteFileFromStringSlice(".\\NeedlessModules.txt", needlessModuleList)
}

func _SummaryAOD(basePath, filter string) ([]FileInfo, error) {
	var err error
	sortInfoList := make([]FileInfo, 0)
	fileInfoList := make([]FileInfo, 0)

	err = filepath.Walk(basePath, func(path string, info os.FileInfo, err error) error {
		if !info.IsDir() {
			var fileInfo FileInfo
			fileInfo.FileName = info.Name()
			fileInfo.FilePath = path
			fileInfo.FileSize = info.Size()
			//fileInfo.ModTime = info.ModTime().Format("2006-01-02 15:04:05")
			if !strings.Contains(fileInfo.FilePath, ".svn") {
				fileInfoList = append(fileInfoList, fileInfo)
			}
		}
		return nil
	})
	if err != nil {
		log.Printf("[ERR]  Get File List Failed: %s\r\n", err.Error())
		return nil, err
	}

	switch filter {
	case "LNB":
		regFilter = regLNB
	case "TNB":
		regFilter = regTNB
	case "SBID":
		regFilter = regSBID
	default:
		return fileInfoList, nil
	}

	for _, i := range fileInfoList {
		reg := regexp.MustCompile(regFilter)
		rst := reg.FindStringSubmatch(i.FileName)
		if len(rst) != 1 {
			continue
		}
		sortInfoList = append(sortInfoList, i)
	}
	return sortInfoList, nil
}

func _SummaryFiles(basePath string) ([]FileInfo, error) {
	var err error
	fileInfoList := make([]FileInfo, 0)

	err = filepath.Walk(basePath, func(path string, info os.FileInfo, err error) error {
		if !info.IsDir() {
			var fileInfo FileInfo
			fileInfo.FileName = info.Name()
			fileInfo.FilePath = path
			fileInfo.FileSize = info.Size()
			//fileInfo.ModTime = info.ModTime().Format("2006-01-02 15:04:05")
			if path == basePath+"\\"+info.Name() {
				fileInfoList = append(fileInfoList, fileInfo)
			}
		}
		return nil
	})
	if err != nil {
		log.Printf("[ERR]  Get File List Failed: %s\r\n", err.Error())
		return nil, err
	}
	return fileInfoList, nil
}

func _RemoveDuplicateElementOfSlice(src []string) []string {
	dst := make([]string, 0, len(src))
	tmp := map[string]struct{}{}
	for _, s := range src {
		if _, ok := tmp[s]; !ok {
			tmp[s] = struct{}{}
			dst = append(dst, s)
		}
	}
	return dst
}

func _WriteFileFromStringSlice(fileName string, dataSlice []string) {
	obj, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
	if err != nil {
		log.Printf("[ERR]  Open File Error: %s\r\n", err.Error())
		return
	}
	defer obj.Close()

	var builder strings.Builder
	for _, s := range dataSlice {
		builder.WriteString(s + "\r\n")
	}
	_, err = obj.WriteString(builder.String())
	if err != nil {
		log.Printf("[ERR]  Write File Error: %s\r\n", err.Error())
		return
	}
}