package pkg

import (
	"regexp"

	"fmt"

	"github.rackspace.com/gorax/tools/util"
)

var (
	v11SyncState        = regexp.MustCompile(`--+((.|\n)*\n)`)
	v11SyncStateColor   = regexp.MustCompile(`Color\s+(\S+)`)
	v11SyncStateStatus  = regexp.MustCompile(`\nStatus\s+(.*)\n`)
	v11SyncStateSummary = regexp.MustCompile(`Summary\s+(.*)\n`)
	v10SyncStateSummary = regexp.MustCompile(`Last\s+Configsync\s+(.*)\n`)
)

type (
	SyncState struct {
		State        *string      `json:"state"`
		Status       *string      `json:"status"`
		Summary      *string      `json:"summary"`
		Details      interface{}  `json:"details"`
		GroupDetails []GroupState `json:"group_details,omitempty"`
	}
	GroupState struct {
		Partition *string `json:"partition,omitempty"`
		Group     *string `json:"group"`
		Status    *string `json:"status"`
		Action    *string `json:"action"`
	}

	DeviceState struct {
		Partition *string `json:"partition,omitempty"`
		Device    *string `json:"device,omitempty"`
		State     *string `json:"state,omitempty"`
		StateTime *string `json:"state_time,omitempty"`
	}

	DeviceLastChange struct {
		LastSelf *string `json:"last_change_self"`
		LastPeer *string `json:"last_change_peer"`
		LastSync *string `json:"last_config_sync"`
	}
)

func ParseV12SyncState(s string) (ret *SyncState) {

	for _, v := range v11SyncState.FindAllStringSubmatch(s, -1) {
		i := regexp.MustCompile(`(?is)Details\n\s+(.*):\s+(\S+)\n\s+(.*)\n\n`).FindStringSubmatch(v[1])
		if i == nil {
			ret = &SyncState{
				State:        util.RegexpFindStringPtr(v11SyncStateColor, v[1]),
				Status:       util.RegexpFindStringPtr(v11SyncStateStatus, v[1]),
				Summary:      nil,
				Details:      nil,
				GroupDetails: nil,
			}
			return
		}
		ret = &SyncState{
			State:   util.RegexpFindStringPtr(v11SyncStateColor, v[1]),
			Status:  util.RegexpFindStringPtr(v11SyncStateStatus, v[1]),
			Summary: util.RegexpFindStringPtr(v11SyncStateSummary, v[1]),
			Details: DeviceState{
				Device: &i[1],
				State:  &i[2],
			},
			GroupDetails: func() (gs []GroupState) {
				for _, m := range regexp.MustCompile(`(?i)\s*(.*?)\s+\((.*?)\).*(\s+-\s+Recommended\s+action:\s+(.*)|)`).FindAllStringSubmatch(i[3], -1) {
					gs = append(gs, GroupState{
						Group:  &m[1],
						Status: &m[2],
						Action: &m[4],
					})
				}
				return
			}(),
		}
	}
	return
}

func ParseV11SyncState(s string) (ret *SyncState) {

	for _, v := range v11SyncState.FindAllStringSubmatch(s, -1) {
		i := regexp.MustCompile(`(?is)Details\n\s+/(\w+)/(.*):\s+(\S+)\s+\(for\s+(\d+).*\)\n\s+(.*)\n\n`).FindStringSubmatch(v[1])
		if i == nil {
			ret = &SyncState{
				State:        util.RegexpFindStringPtr(v11SyncStateColor, v[1]),
				Status:       util.RegexpFindStringPtr(v11SyncStateStatus, v[1]),
				Summary:      nil,
				Details:      nil,
				GroupDetails: nil,
			}
			return
		}
		ret = &SyncState{
			State:   util.RegexpFindStringPtr(v11SyncStateColor, v[1]),
			Status:  util.RegexpFindStringPtr(v11SyncStateStatus, v[1]),
			Summary: util.RegexpFindStringPtr(v11SyncStateSummary, v[1]),
			Details: DeviceState{
				Partition: &i[1],
				Device:    &i[2],
				State:     &i[3],
				StateTime: &i[4],
			},
			GroupDetails: func() (gs []GroupState) {
				for _, m := range regexp.MustCompile(`(?i)/(\w+)/(.*)\s+\((.*)\).*(\s+-\s+Recommended\s+action:\s+(.*)|/|)`).FindAllStringSubmatch(i[5], -1) {
					gs = append(gs, GroupState{
						Partition: &m[1],
						Group:     &m[2],
						Status:    &m[3],
						Action:    &m[5],
					})
				}
				return
			}(),
		}
	}
	return
}

func ParseV10SyncState(s string) (ret *SyncState) {
	for _, v := range regexp.MustCompile(`CONFIG\s+SYNC\s+STATUS((.|\n)*\n)`).FindAllStringSubmatch(s, -1) {
		ls := util.RegexpFindStringPtr(v10SyncStateSummary, v[1])
		sum := ""
		if ls != nil {
			sum = fmt.Sprintf("Last Sync: %v", *ls)
		}
		ret = &SyncState{
			State:   util.RegexpFindStringPtr(regexp.MustCompile(`Status\s+(\S+)`), v[1]),
			Status:  util.RegexpFindStringPtr(regexp.MustCompile(`Status\s+(\S+\s+-\s+(.*)\n|(\S+))`), v[1]),
			Summary: &sum,
			Details: DeviceLastChange{
				LastSelf: util.RegexpFindStringPtr(regexp.MustCompile(`Last\s+change\s+\(Self\)\s+(.*)\n`), v[1]),
				LastPeer: util.RegexpFindStringPtr(regexp.MustCompile(`Last\s+change\s+\(Peer\)\s+(.*)\n`), v[1]),
				LastSync: util.RegexpFindStringPtr(v10SyncStateSummary, v[1]),
			},
		}
	}
	return
}