// Copyright 2018 Open Networking Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package main

import (
	"encoding/json"
	"net"
	"net/http"
	"strconv"

	"github.com/sirupsen/logrus"

	"github.com/gorilla/mux"
)

func (c *Config) getSubscriberHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	sadisRequestID := vars["id"]

	log.WithFields(logrus.Fields{
		"sadisId": sadisRequestID,
	}).Infof("Looking for object %s in XOS database", sadisRequestID)

	defer r.Body.Close()

	subscribers := subscribers{}

	log.Debug("Checking subscribers")

	err := c.fetch("/xosapi/v1/rcord/rcordsubscribers", &subscribers)
	if err != nil {
		log.Errorf("Unable to retrieve subscriber information from XOS: %s", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return

	}

	for _, sub := range subscribers.Subscribers {
		if sub.OnuSerialNumber == sadisRequestID {
			log.Infof("Found subscriber with ID %s", sub.OnuSerialNumber)
			sadisSubscriber := sadisSubscriber{
				ID:        sub.OnuSerialNumber,
				NasPortID: sub.NasPortID,
				CircuitID: sub.CircuitID,
				RemoteID:  sub.RemoteID,
			}

			log.Debugf("Fetching UNI Tag list for subscriber %s", sub.OnuSerialNumber)

			unitaglist := sadisUnitaginfolist{}
			for _, unitagid := range sub.UniTagListId {
				utinfo := unitaginfo{}
				err = c.getOneUniTagInfo(unitagid, &utinfo)
				if err != nil {
					log.Errorf("Cannot fetch UNI tag information%s for subscriber %s", strconv.Itoa(unitagid), sub.OnuSerialNumber)
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				if (unitaginfo{}) == utinfo {
					// it's empty
					log.WithFields(logrus.Fields{
						"UniTagInfoId": unitagid,
						"Subscriber":   sub.OnuSerialNumber,
						"sadisId":      sadisRequestID,
					}).Error("UNI Tag info not found in XOS")
					http.Error(w, "UNI Tag info not found in XOS", http.StatusInternalServerError)
					return
				}
				sadisUnitaginfo := sadisUnitaginfo{
					UniTagMatch:          utinfo.UniTagMatch,
					PonCTag:              utinfo.PonCTag,
					PonSTag:              utinfo.PonSTag,
					UsPonCTagPriority:    utinfo.UsPonCTagPriority,
					UsPonSTagPriority:    utinfo.UsPonSTagPriority,
					DsPonCTagPriority:    utinfo.DsPonCTagPriority,
					DsPonSTagPriority:    utinfo.DsPonSTagPriority,
					TechnologyProfileID:  utinfo.TechnologyProfileID,
					ServiceName:          utinfo.ServiceName,
					EnableMacLearning:    utinfo.EnableMacLearning,
					ConfiguredMacAddress: utinfo.ConfiguredMacAddress,
					IsDhcpRequired:       utinfo.IsDhcpRequired,
					IsIgmpRequired:       utinfo.IsIgmpRequired,
				}

				log.Debugf("Fetching bandwidth profiles for subscriber %s and unitagid: %s", sub.OnuSerialNumber, strconv.Itoa(utinfo.ID))

				dsBandwidthprofile := bandwidthprofile{}
				err = c.getOneBandwidthProfileHandler(utinfo.DownstreamBandwidthProfile, &dsBandwidthprofile)
				if err != nil {
					log.Errorf("Cannot fetch downstream bandwidth profile %s for subscriber %s", strconv.Itoa(utinfo.DownstreamBandwidthProfile), sub.OnuSerialNumber)
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				if (bandwidthprofile{}) == dsBandwidthprofile {
					// it's empty
					log.WithFields(logrus.Fields{
						"DownstreamBandwidthProfile": utinfo.DownstreamBandwidthProfile,
						"Subscriber":                 sub.OnuSerialNumber,
						"sadisId":                    sadisRequestID,
					}).Error("Downstream bandwidth profile not found in XOS")
					http.Error(w, "Downstream bandwidth profile not found in XOS", http.StatusInternalServerError)
					return
				}
				sadisUnitaginfo.DownstreamBandwidthProfile = dsBandwidthprofile.Name

				usBandwidthprofile := bandwidthprofile{}
				err = c.getOneBandwidthProfileHandler(utinfo.UpstreamBandwidthProfile, &usBandwidthprofile)
				if err != nil {
					log.Errorf("Cannot fetch upstream bandwidth profile %s for subscriber %s", strconv.Itoa(utinfo.UpstreamBandwidthProfile), sub.OnuSerialNumber)
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				if (bandwidthprofile{}) == usBandwidthprofile {
					// it's empty
					log.WithFields(logrus.Fields{
						"UpstreamBandwidthProfile": utinfo.UpstreamBandwidthProfile,
						"Subscriber":               sub.OnuSerialNumber,
						"sadisId":                  sadisRequestID,
					}).Error("Upstream bandwidth profile not found in XOS")
					http.Error(w, "Upstream bandwidth profile not found in XOS", http.StatusInternalServerError)
					return
				}
				sadisUnitaginfo.UpstreamBandwidthProfile = usBandwidthprofile.Name

				log.WithFields(logrus.Fields{
					"Subscriber":                 sub.OnuSerialNumber,
					"UniTagInfo":                 utinfo.ID,
					"UpstreamBandwidthProfile":   usBandwidthprofile.Name,
					"DownstreamBandwidthProfile": dsBandwidthprofile.Name,
					"sadisId": sadisRequestID,
				}).Debug("Bandwidth profiles for subscriber/unitaginfo")
				unitaglist.SadisUniTagList = append(unitaglist.SadisUniTagList, &sadisUnitaginfo)
			}
			sadisSubscriber.UniTagList = unitaglist.SadisUniTagList

			sadisjson, e := json.Marshal(&sadisSubscriber)
			if e != nil {
				log.Errorf("Unable to marshal JSON: %s", e)
				http.Error(w, e.Error(), http.StatusInternalServerError)
				return
			}
			w.Write(sadisjson)
			return
		}
	}

	log.Debug("Checking devices")

	devices := oltDevices{}

	err = c.fetch("/xosapi/v1/volt/oltdevices", &devices)
	if err != nil {
		log.Errorf("Unable to retrieve device information from XOS: %s", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return

	}

	for _, device := range devices.OltDevices {
		// NOTE if it's an OLT then sadisRequestID is the device serial number
		devID := device.SerialNumber
		if devID == sadisRequestID {
			log.Infof("Found OLT device with ID %s", devID)

			ipaddr := device.Host
			addr, err := net.ResolveIPAddr("ip", device.Host)
			if err != nil {
				log.Errorf("Resolution error: %s", err.Error())
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			} else {
				ipaddr = addr.String()
			}
			log.Debugf("ID: %s, Uplink: %d, IPAddress: %s, NasID: %s", devID, toInt(device.Uplink), ipaddr, device.NasID)
			sadisDevice := sadisDevice{
				ID:         devID,
				Uplink:     toInt(device.Uplink),
				HardwareID: "de:ad:be:ef:ba:11", // TODO do we really need to configure this?
				IPAddress:  ipaddr,
				NasID:      device.NasID,
			}

			json, e := json.Marshal(&sadisDevice)
			if e != nil {
				log.Errorf("Unable to marshal JSON: %s", e)
				http.Error(w, e.Error(), http.StatusInternalServerError)
				return
			}
			w.Write(json)
			return
		}
	}

	log.WithFields(logrus.Fields{
		"sadisId": sadisRequestID,
	}).Infof("Couldn't find object %s in XOS database", sadisRequestID)

	http.NotFound(w, r)
}

func (c *Config) getBandwidthProfileHandler(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	sadisRequestID := vars["id"]

	log.WithFields(logrus.Fields{
		"sadisId": sadisRequestID,
	}).Infof("Fetching BandwidthProfiles from XOS database")
	defer r.Body.Close()

	bandwidthprofiles := bandwidthprofiles{}

	err := c.fetch("/xosapi/v1/rcord/bandwidthprofiles", &bandwidthprofiles)

	if err != nil {
		log.Errorf("Unable to retrieve bandwidth profiles information from XOS: %s", err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	for _, profile := range bandwidthprofiles.Profiles {
		profileID := profile.Name
		if profileID == sadisRequestID {
			sadisProfile := sadisBandwidthProfile{
				ID:  profile.Name,
				Cir: profile.Cir,
				Cbs: profile.Cbs,
				Eir: profile.Eir,
				Ebs: profile.Ebs,
				Air: profile.Air,
			}
			json, e := json.Marshal(&sadisProfile)
			if e != nil {
				log.Errorf("Unable to marshal JSON: %s", e)
				http.Error(w, e.Error(), http.StatusInternalServerError)
				return
			}
			w.Write(json)
			return
		}
	}

	log.WithFields(logrus.Fields{
		"sadisId": sadisRequestID,
	}).Infof("Couldn't find object %s in XOS database", sadisRequestID)

	http.NotFound(w, r)
}

func (c *Config) getOneBandwidthProfileHandler(id int, data interface{}) error {
	err := c.fetch("/xosapi/v1/rcord/bandwidthprofiles/"+strconv.Itoa(id), &data)
	if err != nil {
		log.Errorf("Unable to retrieve bandwidth profile information from XOS: %s", err)
		return err
	}
	return nil
}

func (c *Config) getOneUniTagInfo(id int, data interface{}) error {
	err := c.fetch("/xosapi/v1/rcord/rcordunitaginformations/"+strconv.Itoa(id), &data)
	if err != nil {
		log.Errorf("Unable to retrieve UNI Tag information from XOS: %s", err)
		return err
	}
	return nil
}

func toInt(value string) int {
	r, _ := strconv.Atoi(value)
	return r
}

func (c *Config) fetch(path string, data interface{}) error {
	resp, err := http.Get(c.connect + path)

	if err != nil {
		return err
	}

	defer resp.Body.Close()
	decoder := json.NewDecoder(resp.Body)
	err = decoder.Decode(data)
	log.WithFields(logrus.Fields{
		"path":   path,
		"resp":   data,
		"status": resp.Status,
	}).Debug("Received data from XOS")
	return err
}