#!/usr/bin/env python3
"""SEEDS Scalping Bot - Quick 0.5-1% trades"""
import time,json,os,sys,logging
from datetime import datetime
logging.basicConfig(level=logging.INFO,format='%(asctime)s [%(levelname)s] %(message)s',handlers=[logging.StreamHandler()])
log=logging.getLogger(__name__)
BOT_DIR=os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0,BOT_DIR)
TRADE_FILE=os.path.join(BOT_DIR,'scalp_trades.json')
CTRL_FILE=os.path.join(BOT_DIR,'bot_control.json')
COINS=[{'pair':'XXRPZUSD','coin':'XRP','capital':20.0},{'pair':'ADAUSD','coin':'ADA','capital':20.0},{'pair':'XDGUSD','coin':'DOGE','capital':20.0}]
TAKE_PROFIT=0.008;STOP_LOSS=0.004;INTERVAL=30;LOOKBACK=10
def load_state():
    try:
        if os.path.exists(TRADE_FILE):
            with open(TRADE_FILE) as f: return json.load(f)
    except: pass
    return {'trades':[],'total_profit':0.0,'positions':{}}
def save_state(s):
    try: open(TRADE_FILE,'w').write(json.dumps(s,indent=2))
    except: pass
def is_enabled():
    try:
        if os.path.exists(CTRL_FILE):
            with open(CTRL_FILE) as f: return json.load(f).get('scalping_enabled',True)
    except: pass
    return True
class ScalpBot:
    def __init__(self,cfg,api):
        self.pair=cfg['pair'];self.coin=cfg['coin'];self.capital=cfg['capital']
        self.api=api;self.prices=[];self.position=None;self.buy_price=0.0;self.volume=0.0
    def get_price(self):
        try:
            r=self.api.query_public('Ticker',{'pair':self.pair})
            if not r.get('error'): return float(list(r['result'].values())[0]['c'][0])
        except: pass
        return None
    def momentum(self):
        if len(self.prices)<LOOKBACK: return 0
        r=sum(self.prices[-3:])/3;o=sum(self.prices[-LOOKBACK:-LOOKBACK+3])/3
        return (r-o)/o if o else 0
    def update(self,state):
        price=self.get_price()
        if not price: return
        self.prices.append(price)
        if len(self.prices)>LOOKBACK*2: self.prices=self.prices[-LOOKBACK*2:]
        log.info(f'[{self.coin}] ${price:.4f} | Mom: {self.momentum()*100:.2f}%')
        if self.position=='long':
            pnl=(price-self.buy_price)/self.buy_price
            log.info(f'[{self.coin}] Position P&L: {pnl*100:.2f}% (${pnl*self.capital:.4f})')
            if pnl>=TAKE_PROFIT: self._sell(price,'take_profit',state)
            elif pnl<=-STOP_LOSS: self._sell(price,'stop_loss',state)
            return
        if len(self.prices)>=LOOKBACK and self.momentum()>0.004:
            self._buy(price,state)
    def _buy(self,price,state):
        try:
            vol=round(self.capital/price,6)
            r=self.api.query_private('AddOrder',{'pair':self.pair,'type':'buy','ordertype':'market','volume':str(vol)})
            if r.get('error'): log.warning(f'[{self.coin}] Buy error: {r["error"]}'); return
            self.position='long';self.buy_price=price;self.volume=vol
            state['positions'][self.coin]={'active':True,'buy_price':price,'volume':vol,'time':datetime.now().isoformat()}
            save_state(state);log.info(f'[{self.coin}] SCALP BUY @ ${price:.4f}')
        except Exception as e: log.error(f'Buy error: {e}')
    def _sell(self,price,reason,state):
        try:
            r=self.api.query_private('AddOrder',{'pair':self.pair,'type':'sell','ordertype':'market','volume':str(self.volume)})
            if r.get('error'): log.warning(f'[{self.coin}] Sell error: {r["error"]}'); return
            net=(price-self.buy_price)*self.volume-(self.buy_price+price)*self.volume*0.0013
            state['total_profit']=round(state.get('total_profit',0)+net,4)
            state['trades'].append({'coin':self.coin,'buy_price':self.buy_price,'sell_price':price,'profit_usd':round(net,4),'reason':reason,'time':datetime.now().isoformat()})
            state['positions'][self.coin]={'active':False};save_state(state)
            self.position=None;self.buy_price=0.0;log.info(f'[{self.coin}] SCALP SELL @ ${price:.4f} | {reason} | Net: ${net:.4f}')
        except Exception as e: log.error(f'Sell error: {e}')
def main():
    import krakenex
    from config_advanced import API_KEY,API_SECRET
    api=krakenex.API(key=API_KEY,secret=API_SECRET)
    state=load_state();bots=[ScalpBot(cfg,api) for cfg in COINS]
    for bot in bots:
        pos=state.get('positions',{}).get(bot.coin,{})
        if pos.get('active'): bot.position='long';bot.buy_price=pos.get('buy_price',0);bot.volume=pos.get('volume',0)
    log.info('='*60);log.info('SEEDS Scalping Bot | LIVE');log.info('='*60)
    cycle=0
    while True:
        try:
            if not is_enabled(): log.info('[Scalp] Disabled');time.sleep(30);continue
            cycle+=1;log.info(f'--- Scalp Cycle {cycle} | {datetime.now().strftime("%Y-%m-%d %H:%M:%S")} ---')
            for bot in bots: bot.update(state);time.sleep(2)
            log.info(f'SUMMARY | P&L: ${state["total_profit"]:.4f} | Trades: {len(state["trades"])}')
            time.sleep(INTERVAL)
        except KeyboardInterrupt: break
        except Exception as e: log.error(f'Error: {e}');time.sleep(15)
if __name__=='__main__': main()