package modules

import (
	"errors"
	"fmt"
)

type sub_manager struct {
	// NameList의 노드들이 각각의 list를 갖음
	list NameList

	/* sub# 관리 */
	count_sub  int             // Subscription #
	emptylist  []int           // To administrate sub #
	num2sub    map[int]MsgUnit // num2sub[sub#] = msg
	sub2num    map[MsgUnit]int // delete시에 관리를 위해
	israngesub map[int]bool    // delete시에 관리를 위해
}

//	### To Insert sub#
func (manager *sub_manager) add_subscription(msg MsgUnit) error {

	name := msg.(*SubscriptionMsg).subscription
	value := msg.(*SubscriptionMsg).value
	subnumber := 0

	fmt.Println("name = ", name, " value = ", value) // for debugging

	// * 1. 들어온 Msg -> sub#, sub# -> Msg로 매핑
	if len(manager.emptylist) == 0 {
		manager.num2sub[manager.count_sub] = msg
		manager.sub2num[msg] = manager.count_sub
		subnumber = manager.count_sub
		manager.count_sub++
	} else {
		subidx := manager.emptylist[len(manager.emptylist)-1]
		manager.emptylist = manager.emptylist[:len(manager.emptylist)-1]
		manager.num2sub[subidx] = msg
		manager.sub2num[msg] = subidx
		subnumber = subidx
	}

	// * 2. Sub 추가
	nameptr := manager.list.head
	findOk := false

	//namelist에서 name찾고, 없으면 추가
	for nameptr != nil {
		// *  compare함수 구현되기 전 임시로 끼어넣은 것 (이 부분은 secure.go 완성되면 다시 확인)
		if compare(nameptr.name, name) == 1 {
			findOk = true
			break
		}
		nameptr = nameptr.next
	}

	if findOk == false {
		newNode := &NameNode{name, nil, List{}}
		manager.list.tail.next = newNode
		manager.list.tail = newNode
		manager.list.size++
		nameptr = manager.list.tail
	}

	// *  ---  가정  ---
	// *  데이터의 value형식은 아래의 두 개 꼴로만 들어온다고 가정
	// *  	(1). {enc(val), op}  == 부등식
	// *       -> (ex)  {2, '<'} , { "baseball", == }
	// *  	(2). {부등식, '&&', 부등식}  or {부등식, '||', 부등식}
	// *       -> (ex1)  {2, '<=', '&&', 3 , '>'}   ==  {2 <= x < 3}
	// *          (ex2)  {12, '<', '||', 5 , '>'}   ==  {12 < x || x < 5}
	// *  -------------

	// list[name]에 value추가
	if len(value) == 2 { // 단일 식이라면 (single)
		valptr := nameptr.list.head
		for valptr != nil {
			// * 이 부분도 compare함수 구현하면 다시봐야함
			if compare(valptr.val, conv(value[0])) == 1 { // value와 같은 val을 갖는 노드가 존재한다면
				valptr.insert_Sub(value[1], subnumber, true)
				return nil // add_subscription ok
			}
			valptr = valptr.next
		}

		// value와 일치하는 노드가 x -> 추가
		nameptr.list.add_ValueNode(value[0], value[1], subnumber, true)

		return nil // add_subscription ok
	} else {

		// rangesub check
		manager.israngesub[subnumber] = true

		// '&&' , '||'로 묶여 있는 복합식에 대하여
		logical_operator := value[2]

		// find(namelist[name].list.val == value)인 노드
		valptr1 := nameptr.list.getPos(conv(value[0]))
		valptr2 := nameptr.list.getPos(conv(value[3]))

		if logical_operator == "&&" { // '&&'로 묶여있다면
			if valptr1 != nil && valptr2 != nil { // val1, val2를 갖는 노드가 둘 다 존재
				valptr1.insert_Sub(value[1], subnumber, false)
				valptr2.insert_Sub(value[4], subnumber, false)
			}
			if valptr1 == nil {
				nameptr.list.add_ValueNode(value[0], value[1], subnumber, false)
			}
			if valptr2 == nil {
				nameptr.list.add_ValueNode(value[3], value[4], subnumber, false)
			}

		} else {

			// '||'로 묶여 있다면 두 식 모두 single로 처리가능

			if valptr1 != nil && valptr2 != nil { // val1, val2를 갖는 노드가 둘 다 존재
				valptr1.insert_Sub(value[1], subnumber, true)
				valptr2.insert_Sub(value[4], subnumber, true)
			}
			if valptr1 == nil {
				nameptr.list.add_ValueNode(value[0], value[1], subnumber, true)
			}
			if valptr2 == nil {
				nameptr.list.add_ValueNode(value[3], value[4], subnumber, true)
			}
		}
		return nil
	}
	return errors.New("Can't add_subscription")
}

//	* ### To delete sub#
func (manager *sub_manager) delete(subnumber int) error {
	s := errors.New("!23")
	return s
}

// * string형태로 암호화 되어있는 value -> int64[]로 변환(임시)
func conv(val string) []int64 {
	ret := make([]int64, len(val))
	return ret
}

// * 암호화된 두 value 비교함수 (임시)
func compare(v1 []int64, v2 []int64) int {
	return 1
}