package main

import (
  "bufio"
  "fmt"
  "math/rand"
  "os"
  "time"

  "github.com/gosuri/uilive"
  "github.com/mattn/go-tty"

  "git.tcp.direct/kayos/Prox5"
)

var quit chan bool
var ui *uilive.Writer
var t *tty.TTY

var listen = "127.0.0.1:9988"
var socksFile = "socks.txt"

var Swamp *Prox5.Swamp

func init() {
  for i, arg := range os.Args {
    if arg == "-l" || arg == "-listen" || arg == "--listen" {
      listen = os.Args[i+1]
    }
    if arg == "-f" || arg == "-file" || arg == "--file" {
      socksFile = os.Args[i+1]
    }
  }

  Swamp = PrepSwamp()
  Swamp.SetDialerBailout(15)

  go StartLocalUpstreamProxy(listen)
  ui = uilive.New()
}

func PrepSwamp() *Prox5.Swamp {
  s := Prox5.NewDefaultSwamp()
  s.SetMaxWorkers(20)
  s.EnableRecycling()
  s.AddCheckEndpoints([]string{"https://icanhazip.com"})
  s.Start()

  var count = 0

  for _, prox := range loadAndShuffle(socksFile) {
    if s.LoadSingleProxy(prox) {
      count++
    }
  }

  fmt.Println("Loaded and shuffled socks proxies for validation: ", count)
  return s
}

func loadAndShuffle(file string) (proxies []string) {
  f, err := os.Open(file)
  defer f.Close()
  if err != nil {
    println("Failed to open file: " + err.Error())
    os.Exit(1)
    return []string{}
  }

  var ogProxies []string
  xerox := bufio.NewScanner(f)
  for xerox.Scan() {
    ogProxies = append(ogProxies, xerox.Text())
  }

  proxies = make([]string, len(ogProxies))
  rand.Seed(time.Now().UnixNano())
  perm := rand.Perm(len(ogProxies))
  for i, v := range perm {
    proxies[v] = ogProxies[i]
  }
  return proxies
}

func watchKeyPresses() {
  var err error
  t, err = tty.Open()
  if err != nil {
    panic(err)
  }
  var done = false

  for {
    r, err := t.ReadRune()
    if err != nil {
      panic(err)
    }
    switch string(r) {
    case "d":
      if Swamp.DebugEnabled() {
        println("Disabling debug")
        Swamp.DisableDebug()
      } else {
        println("Enabling debug")
        Swamp.EnableDebug()
      }
    case "+":
      Swamp.SetMaxWorkers(Swamp.GetMaxWorkers() + 1)
    case "-":
      Swamp.SetMaxWorkers(Swamp.GetMaxWorkers() - 1)
    case "p":
      if Swamp.IsRunning() {
        err := Swamp.Pause()
        if err != nil {
          println(err.Error())
        } 
      } else {
        if err := Swamp.Resume(); err != nil {
          println(err.Error())
        }
      }
    case "q":
      done = true
      break
    default:
    }
    if done {
      break
    }
  }

  quit <- true
  return
}

func ticker() {
  println("controls:; (p) pause/resume | (d) debug on/off | (+/-) change worker count | (q) quit")
  go watchKeyPresses()
  ui.Start()
  for {
    mw, rw, iw := Swamp.GetWorkers()
    stats := Swamp.GetStatistics()
    total := stats.Valid4 + stats.Valid5 + stats.Valid4a
    _, _  = fmt.Fprintf(ui, "Working: %d | Idle: %d | Max: %d\n\nChecked: %d\nValidated: %d\nDispensed: %d\n", rw, iw, mw, stats.Checked, total, stats.Dispensed)
    time.Sleep(25 * time.Millisecond)
    ui.Flush()
  }
}

func main() {
  go ticker()
  <-quit
}