#include <contract.c>

vars PriceClose;
var Volatility;

void initFuzzyLogicSettings() {
  FuzzyRange = 0.05; // Adjust based on backtesting
}

var calculateVolatility(vars Data, int period) {
  var sumDelta = 0;
  for(int i = 1; i <= period; i++) {
    sumDelta += abs(Data[i] - Data[i-1]);
  }
  return sumDelta / period;
}

var adjustFuzzyForVolatility(var fuzzyValue) {
  var adjustmentFactor = 1 + Volatility * 10;
  return clamp(fuzzyValue / adjustmentFactor, 0, 1);
}

bool fuzzyEntryCondition(vars Data) {
  var entryFuzzy = max(risingF(Data), valleyF(Data));
  return adjustFuzzyForVolatility(entryFuzzy) > 0.5;
}

bool fuzzyExitCondition(vars Data) {
  var exitFuzzy = max(fallingF(Data), peakF(Data));
  return adjustFuzzyForVolatility(exitFuzzy) > 0.5;
}

void optionComboTrade() {
  CONTRACT* C1; // Define pointer for the first leg of the combo
  CONTRACT* C2; // Define pointer for the second leg of the combo
  
  // Dynamically adjust option strike based on current price and volatility
  var strikeCall = round(priceClose(0) + 10 + Volatility * 5); // Example for call strike
  var strikePut = round(priceClose(0) - 10 - Volatility * 5); // Example for put strike
  
  // Initialize contracts for a strangle combo
  C1 = contractFind(CALL, 30, strikeCall); // Find call option contract
  C2 = contractFind(PUT, 30, strikePut); // Find put option contract

  // Check if contracts are found and if entry condition is met
  if(C1 && C2 && fuzzyEntryCondition(PriceClose)) {
    combo(C1, 1, C2, 1, 0, 0, 0, 0); // Create a strangle combo
    enterLong(comboLeg(1)); // Enter long on both legs of the combo
    enterLong(comboLeg(2));
  }
}

void run() {
  BarPeriod = 60;
  LookBack = 100;
  StartDate = 2020;
  EndDate = 2024;
  assetList("AssetsIB");
  asset("SPY");

  PriceClose = series(priceClose());
  initFuzzyLogicSettings();

  Volatility = calculateVolatility(PriceClose, 20); // Calculate market volatility

  if (is(EXITRUN)) return;

  optionComboTrade(); // Execute the option combo trade based on fuzzy logic conditions
}

#include <contract.c>

vars PriceClose, VolatilityEMA;

void init() {
  assetList("AssetsIB");
  BarPeriod = 60; // Setting bar period for the price series
  LookBack = 100; // Lookback period for technical indicators

  PriceClose = series(priceClose());
  initFuzzyLogicSettings();
  calculateEMAVolatility(20); // Initialize volatility calculation
}

void initFuzzyLogicSettings() {
  FuzzyRange = 0.05; // Adjust based on backtesting
}

void calculateEMAVolatility(int period) {
  vars ATRValues = series(ATR(period));
  VolatilityEMA = series(EMA(ATRValues, period));
}

void tradeOptions() {
  // Assuming current asset is SPY and we're setting up a strangle
  if (NumOpenLong == 0 && fuzzyEntryCondition()) {
    // Find contracts for the call and put options
    CONTRACT* callContract = contractFind("Call", 30, priceClose(0) + 10); // Example: 30 days to expiration, strike 10 points above
    CONTRACT* putContract = contractFind("Put", 30, priceClose(0) - 10); // Example: 30 days to expiration, strike 10 points below

    if(callContract && putContract) {
      // Setup the combo - buying 1 call and 1 put
      combo(callContract, 1, putContract, 1, 0, 0, 0, 0);
      
      // Enter the combo trade
      enterLong(comboLeg(1)); // Enter long for the call option leg
      enterLong(comboLeg(2)); // Enter long for the put option leg
      
      printf("\nEntered a Strangle on SPY");
    }
  }
}

void run() {
  StartDate = 2020;
  EndDate = 2024;
  assetList("AssetsIB");
  asset("SPY");

  while(asset(loop("SPY","AAPL","MSFT"))) {
    if (is(EXITRUN)) continue;
    tradeOptions();
  }
}

#include <contract.h>

// Initialize global variables for storing price and volatility data
vars PriceClose, VolatilityEMA;

void init() {
  assetList("AssetsIB");
  BarPeriod = 60;
  LookBack = 100;
  StartDate = 2020;
  EndDate = 2024;
  
  PriceClose = series(priceClose());
  initFuzzyLogicSettings();
  calculateEMAVolatility(20); // Initialize volatility calculation
}

void initFuzzyLogicSettings() {
  FuzzyRange = 0.05; // Adjust based on backtesting
}

void calculateEMAVolatility(int period) {
  vars ATRValues = series(ATR(period));
  VolatilityEMA = series(EMA(ATRValues, period));
}

// Cumulative Normal Distribution Function for use in Black-Scholes Model
var CNDF(var x) {
  int neg = (x < 0.0) ? 1 : 0;
  if (neg) x = -x;
  
  var k = (1.0 / ( 1.0 + 0.2316419 * x));
  var y = (((1.330274429 * k - 1.821255978) * k + 1.781477937) *
           k - 0.356563782) * k + 0.319381530;
  y = 1.0 - 0.398942280401 * exp(-0.5 * x * x) * y;
  
  return (1.0 - neg) * y + neg * (1.0 - y);
}

// Black-Scholes Option Pricing Model
var BlackScholes(char *CallPutFlag, var S, var X, var T, var r, var v) {
  var d1, d2;
  d1 = (log(S / X) + (r + 0.5 * v * v) * T) / (v * sqrt(T));
  d2 = d1 - v * sqrt(T);
  
  if (CallPutFlag[0] == 'c' || CallPutFlag[0] == 'C') {
    return S * CNDF(d1) - X * exp(-r * T) * CNDF(d2);
  } else {
    return X * exp(-r * T) * CNDF(-d2) - S * CNDF(-d1);
  }
}

bool fuzzyEntryCondition() {
  return risingF(PriceClose) > 0.5 && VolatilityEMA[0] < 0.2;
}

bool fuzzyExitCondition() {
  return fallingF(PriceClose) > 0.5 || VolatilityEMA[0] > 0.3;
}

void tradeOptions() {
  CONTRACT* CallContract;
  CONTRACT* PutContract;
  var strikePrice = round(priceClose(0),100); // Example for rounding to nearest hundred
  var expirationDays = 30; // Targeting options 30 days to expiration

  if (fuzzyEntryCondition()) {
    // Prepare to trade a call option
    CallContract = contractFind("Call", strikePrice, wdate() + expirationDays * 86400);
    if(CallContract) {
      // Buy the call option
      combo(CallContract, 1, 0, 0, 0, 0, 0, 0);
      enterLong(comboLeg(1));
    }
  } else if (fuzzyExitCondition()) {
    // Prepare to trade a put option
    PutContract = contractFind("Put", strikePrice, wdate() + expirationDays * 86400);
    if(PutContract) {
      // Buy the put option
      combo(0, 0, PutContract, 1, 0, 0, 0, 0);
      enterLong(comboLeg(2));
    }
  }
}

void main() {
  init();
  while(asset(loop("Assets"))) {
    if (is(EXITRUN)) continue;
    tradeOptions(); // Execute the option trading logic based on market conditions
  }
}