from nullptr.command_line import CommandLine
from nullptr.store import Store
import argparse
from nullptr.models.agent import Agent
from nullptr.models.system import System
from nullptr.models.waypoint import Waypoint
from nullptr.api import Api
from .util import *
from time import sleep
from threading import Thread

class Commander(CommandLine):
  def __init__(self, store_dir='data', agent=None):
    self.store_dir = store_dir
    self.store = Store(store_dir)
    self.agent = self.select_agent(agent)
    self.api = Api(self.store, self.agent)
    self.store.flush()
    self.stop_auto= False
    super().__init__()
  
  def select_agent(self, agent_str):
    if agent_str is not None:
      return self.store.get(Agent, agent_str)
    else:
      agents = self.store.all('', Agent)
      agent = next(agents, None)
      if agent is None:
        symbol = input('agent name: ')
        agent = self.store.get(Agent, symbol)
      return agent
      
  def after_cmd(self):
    self.store.flush()
      
  def do_info(self):
    pprint(self.api.info(), 100)
    
  def do_register(self, faction):
    self.api.register(faction.upper())
  
  def wait_for_stop(self):
    input()
    self.stop_auto = True
    print('stopping...')
    
  def do_universe(self):
    print('universe mode. hit enter to stop')
    t = Thread(target=self.wait_for_stop)
    t.daemon = True
    t.start()
    self.all_systems()
    print('manual mode')
  
  def all_specials(self, waypoints):
    for w in waypoints:
      if self.stop_auto:
        break
      if 'MARKETPLACE' in w.traits:
        self.api.marketplace(w)
        print(f'marketplace at {w}')
        sleep(0.5)
        
  def all_waypoints(self, systems):
    for s in systems:
      if self.stop_auto:
        break
      r = self.api.list_waypoints(s)
      print(f'system {s}: {len(r)} waypoints')
      self.all_specials(r)
      sleep(0.5)
  
  def all_systems(self):
    self.stop_auto = False 
    data = self.api.list_systems(1)
    pages = total_pages(self.api.last_meta)
    print(f'{pages} pages of systems')
    print(f'page {1}: {len(data)} results')
    self.all_waypoints(data)
    
    
    for p in range(2, pages):
      if self.stop_auto:
        break
      data = self.api.list_systems(p)
      print(f'page {p}: {len(data)} systems')
      self.all_waypoints(data)
      sleep(0.5)
      self.store.flush()
  
  def do_systems(self, page=1):
    r = self.api.list_systems(int(page))
    pprint(self.api.last_meta)
    
  def do_waypoints(self, system_str):
    system = self.store.get(System, system_str.upper())
    r = self.api.list_waypoints(system)
    pprint(r)

  def do_marketplace(self, waypoint_str):
    waypoint = self.store.get(Waypoint, waypoint_str.upper())
    r = self.api.marketplace(waypoint)