package parser
  
  import (
  	"encoding/json"
  	"fmt"
  	"io/ioutil"
  	"strings"
  )
  
  type jsonObject map[string]interface{}
  type jsonArray []interface{}
  
  type Request struct {
  	Log   []string `json:"log"`
  	Sheet Sheet    `json:"sheet"`
  }
  
  type Sheet struct {
  	LogID     string `json:"log_id"`
  	Date      string `json:"date"`
  	Target    string `json:"target"`
  	Memory    string `json:"memory"`
  	StartLine string `json:"start_line"`
  
  	Hardware []SheetEntry `json:"hardware"`
  	OS       []SheetEntry `json:"os"`
  	Device   []SheetEntry `json:"device"`
  }
  
  type SheetEntry struct {
  	Title        string     `json:"title"`
  	Check        [][]string `json:"check"`
  	ErrorMessage []string   `json:"error_message"`
  }
  
  type Parser struct {
  	InChan  chan string
  	OutChan chan jsonObject
  }
  
  func New() *Parser {
  	parser := &Parser{}
  	return parser
  }
  
  func (p *Parser) Parse(request *Request) string {
  	p.start()
  	for _, line := range request.Log {
  		p.InChan <- line
  	}
  	p.stop()
  
  	return p.makeResult(request.Sheet)
  }
  
  func (p *Parser) start() {
  	p.InChan = make(chan string, 100)
  	p.OutChan = make(chan jsonObject, 1)
  
  	// Go parse functions
  	inputChanList := make([]chan string, len(parseFuncList))
  	outputChanList := make([]chan jsonObject, len(parseFuncList))
  	for i, parseFunc := range parseFuncList {
  		f := parseFunc
  
  		inputChan := make(chan string, 10)
  		outputChan := make(chan jsonObject, 1)
  
  		inputChanList[i] = inputChan
  		outputChanList[i] = outputChan
  
  		go func() {
  			defer func() {
  				if r := recover(); r != nil {
  					//p.Fatal("Internal Error", r, string(debug.Stack()))
  				}
  				for range inputChan {
  				}
  				close(outputChan)
  			}()
  			f(inputChan, outputChan)
  		}()
  	}
  
  	// Broadcast input
  	go func() {
  		for input := range p.InChan {
  			for _, inputChan := range inputChanList {
  				inputChan <- input
  			}
  		}
  
  		for _, inputChan := range inputChanList {
  			close(inputChan)
  		}
  	}()
  
  	// Merge output
  	go func() {
  		output := make(jsonObject)
  
  		for _, outputChan := range outputChanList {
  			for parsed := range outputChan {
  				output[parsed["type"].(string)] = parsed
  			}
  		}
  
  		p.OutChan <- output
  		close(p.OutChan)
  	}()
  }
  
  func (p *Parser) stop() {
  	close(p.InChan)
  }
  
  func (p *Parser) makeReport(result jsonObject, checklist []SheetEntry) ([]jsonObject, bool) {
  	var report []jsonObject
  
  	totalPass := true
  
  	for _, entry := range checklist {
  		reportEntry := make(jsonObject)
  		reportEntry["title"] = entry.Title
  
  		pass := true
  		for _, c := range entry.Check {
  			o, ok := result[c[0]].(jsonObject)
  			if !ok {
  				reportEntry["result"] = "FAIL"
  				reportEntry["message"] = entry.ErrorMessage[0]
  				pass = false
  				break
  			}
  			switch o[c[1]].(type) {
  			case string:
  				if len(c[2]) > 0 {
  					v, ok := o[c[1]].(string)
  					if !ok {
  						reportEntry["result"] = "FAIL"
  						reportEntry["message"] = entry.ErrorMessage[0]
  						pass = false
  						break
  					}
  					if strings.Compare(v, c[2]) != 0 {
  						reportEntry["result"] = "FAIL"
  						reportEntry["message"] = entry.ErrorMessage[0]
  						pass = false
  						break
  					}
  				}
  			case []string:
  				if len(c[2]) > 0 {
  					l, ok := o[c[1]].([]string)
  					if !ok {
  						reportEntry["result"] = "FAIL"
  						reportEntry["message"] = entry.ErrorMessage[0]
  						pass = false
  						break
  					}
  
  					found := false
  					for _, v := range l {
  						if strings.Compare(v, c[2]) == 0 {
  							found = true
  						}
  					}
  					if !found {
  						reportEntry["result"] = "FAIL"
  						reportEntry["message"] = entry.ErrorMessage[0]
  						pass = false
  						break
  					}
  				}
  			case []jsonObject:
  				if len(c[2]) > 0 {
  					list, ok := o[c[1]].([]jsonObject)
  					if !ok {
  						reportEntry["result"] = "FAIL"
  						reportEntry["message"] = entry.ErrorMessage[0]
  						pass = false
  						break
  					}
  
  					found := false
  					for _, v := range list {
  						label := v["label"].(string)
  						if strings.Compare(label, c[2]) == 0 {
  							found = true
  						}
  					}
  					if !found {
  						reportEntry["result"] = "FAIL"
  						reportEntry["message"] = entry.ErrorMessage[0]
  						pass = false
  						break
  					}
  				}
  			default:
  				fmt.Printf("%v fail (type: %T)
  ", c[1], o[c[1]])
  				reportEntry["result"] = "FAIL"
  				pass = false
  			}
  		}
  		if pass {
  			reportEntry["result"] = "PASS"
  		} else {
  			totalPass = false
  		}
  		report = append(report, reportEntry)
  	}
  
  	return report, totalPass
  }
  
  func (p *Parser) makeResult(sheet Sheet) string {
  	output := make(jsonObject)
  
  	result := <-p.OutChan
  	report := make(jsonObject)
  
  	pass := true
  	totalPass := true
  
  	result["memory_size"] = sheet.Memory
  
  	report["log_id"] = sheet.LogID
  	report["date"] = sheet.Date
  	report["target"] = sheet.Target
  
  	report["hardware"], pass = p.makeReport(result, sheet.Hardware)
  	totalPass = totalPass && pass
  	report["os"], pass = p.makeReport(result, sheet.OS)
  	totalPass = totalPass && pass
  	report["device"], pass = p.makeReport(result, sheet.Device)
  	totalPass = totalPass && pass
  
  	if totalPass {
  		report["pass"] = "PASS"
  	}
  
  	output["result"] = result
  	output["report"] = report
  
  	b, err := json.MarshalIndent(output, "", "  ")
  	if err == nil {
  		ioutil.WriteFile("anal-kernel-response.json", b, 0644)
  	}
  	return string(b)
  }