// Load all the messages, and sort into a single time-ordered stream.
func file2msgs(filename string) []adsb.Msg {
	file, err := os.Open(filename)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	msgs := []adsb.Msg{}
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		if err := scanner.Err(); err != nil {
			log.Fatal(err)
		}

		msg := adsb.Msg{}
		if err := msg.FromSBS1(scanner.Text()); err != nil {
			log.Fatal("Bad parse '%s'\n%v\n", scanner.Text(), err)
		}

		// We drop the useless "111" fields, so this doesn't work. Maybe add them in, for ToSBS1 ?
		//if msg.ToSBS1() != scanner.Text() {
		//	log.Fatalf("parse/print fail\nread: %s\ngen : %s\n", scanner.Text(), msg.ToSBS1())
		//}

		msgs = append(msgs, msg)
	}
	return msgs
}

func main() {
	Log.Printf("reading file '%s' (dumpPos=%v)", fFilename, fDumpPos)

	h := histogram.Histogram{
		ValMin:     0,
		ValMax:     80,
		NumBuckets: 80,
	}
	_ = h
	if osFile, err := os.Open(fFilename); err != nil {
		Log.Fatal(err)
	} else {
		scanner := bufio.NewScanner(osFile) // os.File implements io.Reader
		for scanner.Scan() {
			m := adsb.Msg{}
			text := scanner.Text()
			if err := m.FromSBS1(text); err != nil {
				Log.Fatal(err)
				break
			}

			if fDumpPos {
				if m.HasPosition() {
					fmt.Printf("\"%.5f,%.5f\"\n", m.Position.Lat, m.Position.Long)
				}
			} else {
				Log.Print(m)
			}

		}
		if err := scanner.Err(); err != nil {
			Log.Fatal(err)
		}
	}
}

// MaybeAdd looks at a new message, and updates the buffer as appropriate.
func (mb *MsgBuffer) Add(m *adsb.Msg) {

	mb.ageOutQuietSenders()

	if _, exists := mb.Senders[m.Icao24]; exists == false {
		// We've not seen this sender before. If we have position data,
		// start the whitelisting thing. We only Whitelist senders who
		// will eventually send useful info (e.g. position), so wait until
		// we see that.
		if m.HasPosition() {
			mb.Senders[m.Icao24] = &ADSBSender{LastSeen: time.Now().UTC()}
		}
	} else {
		mb.Senders[m.Icao24].updateFromMsg(m) // Pluck out anything interesting
		if composite := mb.Senders[m.Icao24].maybeCreateComposite(m); composite != nil {
			// We have a message to store !!
			mb.Messages = append(mb.Messages, composite)
		}
	}

	// We use the timestamp in the message to decide when to flush,
	// rather than the time at which we received the message; this is to
	// deliver a better end-to-end QoS for message delivery.

	// But stale messages can arrive, with timestamps from the past;
	// they would always trigger a flush, and flushing every message
	// slows things down (so we never ever catch up again :().
	// So we also enforce a minimum interval between flushes.
	if len(mb.Messages) > 0 {
		t := mb.Messages[0].GeneratedTimestampUTC
		if time.Since(t) >= mb.MaxMessageAge && time.Since(mb.lastFlush) >= mb.MinPublishInterval {
			mb.flush()
		}
	}
}

// If this message has new position info, *and* we have good backfill, then craft a CompositeMsg.
// Note, we don't wait for squawk info.
func (s *ADSBSender) maybeCreateComposite(m *adsb.Msg) *adsb.CompositeMsg {
	if !m.HasPosition() {
		return nil
	}

	//if s.LastGroundSpeed == 0 || s.LastTrack == 0 || s.LastCallsign == "" { return nil }

	cm := adsb.CompositeMsg{Msg: *m} // Clone the input into the embedded struct

	// Overwrite with cached info (from previous packets), if we don't have it in this packet
	if cm.GroundSpeed == 0 {
		cm.GroundSpeed = s.LastGroundSpeed
	}
	if cm.VerticalRate == 0 {
		cm.VerticalRate = s.LastVerticalSpeed
	}
	if cm.Track == 0 {
		cm.Track = s.LastTrack
	}
	if cm.Callsign == "" {
		cm.Callsign = s.LastCallsign
	}
	if cm.Squawk == "" {
		cm.Squawk = s.LastSquawk
	}

	return &cm
}

func msgs(sbs string) (ret []adsb.Msg) {
	scanner := bufio.NewScanner(strings.NewReader(sbs))
	for scanner.Scan() {
		m := adsb.Msg{}
		text := scanner.Text()
		if err := m.FromSBS1(text); err != nil {
			panic(err)
		}
		m.GeneratedTimestampUTC = time.Now() // Fake this out
		ret = append(ret, m)
	}
	return
}

// Parse up the SBS strings, and then pretend we've fleshed them out with data into CompositeMsgs
func msgs(sbsText string) (ret []*adsb.CompositeMsg) {
	scanner := bufio.NewScanner(strings.NewReader(sbsText))
	for scanner.Scan() {
		if text := scanner.Text(); text != "" {
			m := adsb.Msg{}
			if err := m.FromSBS1(text); err != nil {
				panic(err)
			}
			cm := adsb.CompositeMsg{Msg: m}
			ret = append(ret, &cm)
		}
	}
	return
}

func TestAgeOutQuietSenders(t *testing.T) {
	mb := NewMsgBuffer()
	messages := msgs(maybeAddSBS)
	for _, msg := range messages {
		mb.Add(&msg)
	}

	unrelatedMsg := adsb.Msg{}
	if err := unrelatedMsg.FromSBS1(unrelatedSBS); err != nil {
		panic(err)
	}

	// Pluck out the (only) sender ID, reset its clock into the past
	var id adsb.IcaoId
	for k, _ := range mb.Senders {
		id = k
	}

	// Rig time - just before the age out window
	offset := -1*mb.MaxQuietTime - 5
	mb.Senders[id].LastSeen = mb.Senders[id].LastSeen.Add(offset)
	mb.Add(&unrelatedMsg) // Send a message, to trigger ageout
	if len(mb.Senders) != 1 {
		t.Errorf("aged out too soon ?")
	}

	// Rig time - just after the age out window. And reset the sweep time.
	mb.Senders[id].LastSeen = mb.Senders[id].LastSeen.Add(time.Duration(-10) * time.Second)
	mb.lastAgeOut = mb.lastAgeOut.Add(time.Second * time.Duration(-5))
	mb.Add(&unrelatedMsg) // Send a message, to trigger ageout
	if len(mb.Senders) != 0 {
		t.Errorf("aged out, but still present")
	}

	_ = fmt.Sprintf("%s", mb)
}

func generateData() {
	fmt.Printf("(launching mock dump0190 on localhost:%d; mlat=%v)\n", port, mlat)

	ln, _ := net.Listen("tcp", fmt.Sprintf("localhost:%d", port))

outerLoop:
	for {
		conn, _ := ln.Accept()
		fmt.Printf("(connection started)\n")

		m := adsb.Msg{
			Icao24:                adsb.IcaoId("A81BD0"),
			Callsign:              "ABW123",
			Type:                  "MSG",
			Altitude:              12345,
			GroundSpeed:           300,
			Track:                 315,
			VerticalRate:          64,
			Position:              geo.Latlong{36.0, -122.0},
			GeneratedTimestampUTC: time.Now().UTC(),
			LoggedTimestampUTC:    time.Now().UTC(),
		}

		// We need to prime the pump, and trick the msgbuffer
		m.SubType = 3 // Get an entry in the sender table for our Icao, by proving we have pos data
		conn.Write([]byte(fmt.Sprintf("%s\n", m.ToSBS1())))
		m.SubType = 1 // Populate the sender table entry with a callsign (MSG,1 only)
		conn.Write([]byte(fmt.Sprintf("%s\n", m.ToSBS1())))
		m.SubType = 4 // Populate the sender table entry with velocity data (MSG,4 only)
		conn.Write([]byte(fmt.Sprintf("%s\n", m.ToSBS1())))
		m.SubType = 3 // All future messages are linear position updates (MSG,3 only)

		for {
			now := time.Now().UTC().Add(-1 * delay)
			m.Position.Lat += 0.01
			m.GeneratedTimestampUTC = now
			m.LoggedTimestampUTC = now

			if mlat {
				m.Type = "MLAT"
			}

			if _, err := conn.Write([]byte(fmt.Sprintf("%s\n", m.ToSBS1()))); err != nil {
				fmt.Printf("(connection ended)\n")
				continue outerLoop
			}

			time.Sleep(time.Millisecond * 1000)
		}
	}
}

// Some subtype packets have data we don't get in the bulk of position packets (those of subtype:3),
// so just cache their interesting data and inject it into next position packet.
// http://woodair.net/SBS/Article/Barebones42_Socket_Data.htm
func (s *ADSBSender) updateFromMsg(m *adsb.Msg) {
	s.LastSeen = time.Now().UTC()

	// If the message had any of the optional fields, cache the value for later
	if m.HasCallsign() {
		if len(m.Callsign) > 0 {
			s.LastCallsign = m.Callsign
		} else {
			s.LastCallsign = "_._._._." // Our nil value :/
		}
	}
	if m.HasSquawk() {
		s.LastSquawk = m.Squawk
	}
	if m.HasGroundSpeed() {
		s.LastGroundSpeed = m.GroundSpeed
	}
	if m.HasTrack() {
		s.LastTrack = m.Track
	}
	if m.HasVerticalRate() {
		s.LastVerticalSpeed = m.VerticalRate
	}

	if m.Type == "MSG_foooo" {
		if m.SubType == 1 {
			// TODO: move this to m.hasCallsign()
			// MSG,1 - the callsign/ident subtype - is sometimes blank. But we
			// don't really want to confuse flights that have a purposefully
			// blank callsign with those for yet we've yet to receive a MSG,1.
			// So we use a magic string instead.
			if m.Callsign == "" {
				s.LastCallsign = "_._._._."
			}
			if m.Callsign != "" {
				s.LastCallsign = m.Callsign
			}

		} else if m.SubType == 2 {
			if m.HasGroundSpeed() {
				s.LastGroundSpeed = m.GroundSpeed
			}
			if m.HasTrack() {
				s.LastTrack = m.Track
			}

		} else if m.SubType == 4 {
			if m.HasGroundSpeed() {
				s.LastGroundSpeed = m.GroundSpeed
			}
			if m.HasVerticalRate() {
				s.LastVerticalSpeed = m.VerticalRate
			}
			if m.HasTrack() {
				s.LastTrack = m.Track
			}

		} else if m.SubType == 6 {
			if m.Squawk != "" {
				s.LastSquawk = m.Squawk
			}
		}
	}
}

// readMsgFromSocket will pull basestation (and extended basestation)
// formatted messages from the socket, and send them down the channel.
// It will retry the connection on failure.
func readMsgFromSocket(wg *sync.WaitGroup, hostport string, msgChan chan<- *adsb.Msg) {
	nTimeMismatches := 0
	lastBackoff := time.Second

	wg.Add(1)

outerLoop:
	for {
		if weAreDone() {
			break
		} // outer

		conn, err := net.Dial("tcp", hostport)
		if err != nil {
			Log.Printf("connect '%s': err %s; trying again in %s ...", hostport, err, lastBackoff*2)
			time.Sleep(lastBackoff)
			if lastBackoff < time.Minute*5 {
				lastBackoff *= 2
			}
			continue
		}

		lastBackoff = time.Second
		Log.Printf("connected to '%s'", hostport)

		// a net.Conn implements io.Reader
		scanner := bufio.NewScanner(conn)
		for scanner.Scan() { // This can block indefinitely ...
			if weAreDone() {
				break outerLoop
			}

			if err := scanner.Err(); err != nil {
				Log.Printf("killing connection, scanner err: %v\n", err)
				conn.Close()
				break // inner
			}

			msg := adsb.Msg{}
			text := scanner.Text()
			if err := msg.FromSBS1(text); err != nil {
				Log.Printf("killing connection, SBS  input:%q, parse fail: %v", text, err)
				break // inner
			}

			// If there is significant clock skew, we should bail. But, it seems
			// that sometimes we pick up stale data from dump1090; so wait to see
			// if it passes.
			offset := time.Since(msg.GeneratedTimestampUTC)
			if offset > time.Minute*30 || offset < time.Minute*-30 {
				nTimeMismatches++
				if nTimeMismatches < 100 {
					continue // do not process this message
				} else {
					Log.Fatalf("100 bad msgs; set -timeloc ?\nNow = %s\nmsg = %s\n", time.Now(),
						msg.GeneratedTimestampUTC)
				}
			}

			// If the message is flagged as one we should mask, honor that
			if msg.IsMasked() {
				continue
			}

			msgChan <- &msg
		}
	}

	wg.Done()
	Log.Printf(" ---- readMsgFromSocket, clean shutdown\n")
}