Indicatore Money Management

//@version=5

// Il trading system completo - Swing-Trend-Trailing ETH/USDT.P BYBIT 4H LONG E SHORT (Strategia Trend Following Con Swing Di Posizione)
// (Sviluppo Dati Exchange = FTX)
// (Exchange= BYBIT) (Sottostante ETH-USDT.P) (Timeframe= 4H) (Direzione= LONG E SHORT) (Swing Posizione= SI) (Esclusione Ore=NO) (Esclusione Giorni=NO') (Esclusione Mesi=NO)
// (Take Profit Long/Short Market = Trailing) (Take Profit Limit Long/Short= NO)
// (Stop Loss Limit Long/Short= -10%) (Stop Loss Market Long/Short= SI) (Stop Loss Market Long/Short= SI) (Trailing Stop=SI) (Stop Emergenza= NO)
// (Rischio Operazione 2% Perdita Media) (Max Drawdown Permesso 10,21%)
// (In Sample Dal=17/08/2017 Al 17/10/2020) (Out Of Sample Dal=18/10/2020 Al 15/03/2021)
// (Progettatta Il=15/03/2021)


strategy(title='Indicatore Money Management', overlay=true,
         max_bars_back=5000, // Serve Per Caricare Più Storico Per Il Trailing Stop
         pyramiding=0,
         initial_capital=1000,
         commission_type=strategy.commission.percent,
         commission_value=0.1,
         slippage=3,
         default_qty_type=strategy.percent_of_equity,
         precision=4,
         default_qty_value=24)


//////////////////////////////////////////////////////////////////////////// Start Money Management ////////////////////////////////////////////////////////////////////////////
// Start Money Management //
InitialCapital = input.float(defval = 1000, title="Initial Capital", group="Capital Management", step=0.1)
FixedContracts = input.float(defval=1.0, minval=0.001, maxval=100000, step=0.001, title= "FixedContracts", group="Capital Management")
EntryCapitalPercent = input.float(defval = 24, title="Entry Capital Percent", group="Capital Management", step=0.1)

MM_Method = input(0, "MM_Method", group="Money Management Method")
Period_ATR = input(14, "Period ATR MM_Method", group="Atr/Adx MM_Method 5/12")
Min_Contract = input.float(1, minval=0.001, step=0.001, title="Min_Contract", group="Money Management Method")
Max_Contract = input.float(100, minval=0.001, step=0.001, title="Max_Contract", group="Money Management Method")
MaxcontractBalancePerc = input.int(defval=10, minval=1, maxval=100000, step=1, title= "Max Contract Balance Perc", group="Money Management Method", tooltip="Max Balance Percent Size Allowed")
OnOffContractBalancePerc = input.bool(defval=false, title= "On-Off Contract Balance Perc", group="Money Management Method")
OnOffContractMaxMin = input.bool(defval=false, title= "On-Off ContractMaxMin", group="Money Management Method")
Monetary_Risk = input.float(defval=74.07, minval=0.0001, maxval=100000, step=0.1, title="Monetary_Risk", group="Percent F", tooltip = "Put Your Monetary Stop Loss Or If No Data, The Average Monetary Stop Loss")
RoundPositionSize = input.bool(defval=false, title= "Round Position Size", group="Money Management Method")

StopLossPercent = input.float(defval = 10, title="Stop Loss Percent MM_Method", group="Take Profit / Stop Loss EM-Risk/EM-RiskBalance%", step=0.1)
TakeProfitPercent = input.float(defval = 10, title="Take Profit Percent MM_Method", group="Take Profit / Stop Loss EM-Risk/EM-RiskBalance%", step=0.1)

MaxDrawdownPercentCalculator = input.float(defval = 70, maxval= 100, title="Max Drawdown Percent Calculator", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= "Calculate Plot % Of Max Drawdown Strips. All Size Strips Must be the Same to Entry Capital Percent before the calculation !!!.")
StartFirstStrip = input.float(defval = -6.58, title="Start First Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " % Of Max Drawdown Where Strip 1 Begins")
EndFirstStrip = input.float(defval = -7.52, title="End First Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " % Of Max Drawdown Where 1 Strip Ends")
StartSecondStrip = input.float(defval = -7.52, title="Start Second Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " % Of Max Drawdown Where Strip 2 Begins")
EndSecondStrip = input.float(defval = -8.46, title="End Second Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " % Of Max Drawdown Where 2 Strip Ends")
StartThirdStrip = input.float(defval = -8.46, title="Start Third Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " % Of Max Drawdown Where Strip 3 Begins")
EndThirdStrip = input.float(defval = -100, title="End Third Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " % Of Max Drawdown Where 3 Strip Ends")
SizePercentFirstStrip = input.float(defval = 21.6, title="Size Percent First Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " Size % 1 Strip")
SizePercentSecondStrip = input.float(defval = 19.2, title="Size Percent Second Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " Size % 2 Strip")
SizePercentThirdStrip = input.float(defval = 16.8, title="Size Percent Third Strip", step=0.1, group="Entry Capital/Balance Percent Relative DD Perc", tooltip= " Size % 3 Strip")

WorstLossRealized = input.float(defval = 230.14, minval = 0.1, maxval=100000, title="Worst Loss Realized", group="Percent F", step=0.1, tooltip= "Put Your Max Monetary Loss")
MaxDDMonetaryLoss = input.float(defval = 1026.9578, minval = 0.1, maxval=100000, title="Max DD Monetary Loss", group="Percent F", step=0.1, tooltip= "Put Your Max DD Monetary Loss")
Ratio = input.float(defval = 250, minval = 0.1, maxval=100000, title="Ratio", group="Fixed Ratio", step=0.1)
FixedRationContractDecimals = input.string(defval = "1", title ="Fixed Ratio Contract Decimals", options = ["1", "0.1", "0.01", "0.001"], group="Fixed Ratio")
inTruncate = input.int(defval=1, minval=1, maxval=100000, step=1, title= "Truncate", group="Fixed Ratio")
FixedRatioContractsDebug = input.float(defval=1, minval=1, maxval=100000, step=1, title= "FixedRatioContractsDebug", group="Fixed Ratio")

StartAfterClosedTrades = input.int(defval=5, minval=1, maxval=100000, step=1, title= "Start After Closed Trades", group="Win/Loss Ratio", tooltip="Win/Loss Ratio MM_Method Will Start Woking After Input Closed Trades")
WinLossPercentageSup = input.float(defval=35, minval=1, maxval=100, step=1, title= "Win Loss Percentage Sup", group="Win/Loss Ratio", tooltip="Set A Parameter Win Loss % Sup")
WinLossPercentageInf = input.float(defval=25, minval=1, maxval=100, step=1, title= "Win Loss Percentage Inf", group="Win/Loss Ratio", tooltip="Set A Parameter Win Loss % Inf")
SizeWinLossPercentageSup = input.float(defval=15, minval=1, maxval=100, step=1, title= "Size Win Loss Percentage =Sup", group="Win/Loss Ratio", tooltip="Change The Entry Size Win/Loss >= Input")
SizeWinLossPercentageInf = input.float(defval=10, minval=1, maxval=100, step=1, title= "Size Win Loss Percentage =Inf", group="Win/Loss Ratio", tooltip="Change The Entry Size Win/Loss <= Input")

EntryCapitalPercentZScore = input.float(defval = 24, title="Entry Capital Percent Z Score", group="Z Score Trade Dependency", step=0.1)
EntryCapitalPercentZScorePositiveStrips = input.float(defval = 10, title="Entry Capital Percent Z Score Positive Strips", group="Z Score Trade Dependency", step=0.1)
EntryCapitalPercentZScoreNegativeStrips = input.float(defval = 5, title="Entry Capital Percent Z Score Negative Strips", group="Z Score Trade Dependency", step=0.1)
MaxPositiveStrips = input.int(defval = 2, minval=0, title="Max Positive Strips", group="Z Score Trade Dependency", step=1, tooltip = "If Count Won Trades == Input, Position Size = Entry Capital Percent Z Score Positive Strips, [If 0 Entry Capita lPercent Z Score]")
MaxNegativeStrips = input.int(defval = 2, minval=0, title="Max Negative Strips", group="Z Score Trade Dependency", step=1, tooltip = "If Count Lost Trades == Input, Position Size = Entry Capital Percent Z Score Negative Strips, [If 0 Entry Capital Percent Z Score]")


// Truncate() truncates a given number to the specified number of decimals.
Truncate(number, decimals) =>
    factor = math.pow(10, decimals)
    int(number * factor) / factor

// Start Indicatore Atr
ATRValue = ta.atr(Period_ATR)
plot(MM_Method == 5 or MM_Method == 6 or MM_Method == 7 or MM_Method == 8 ? ATRValue : na, title="ATR Value MM_Method", display = display.data_window)

// Start Indicatore Adx
len = input.int(14, maxval=100, minval=1, title="DI Length MM_Method", group="Atr/Adx MM_Method 5/12")
lensig = input.int(14, title="ADX Smoothing MM_Method", minval=1, maxval=50, group="Atr/Adx MM_Method 5/12")
[_, _, adx] = ta.dmi(len, lensig)
plot(MM_Method == 9 or MM_Method == 10 or MM_Method == 11 or MM_Method == 12 ? adx : na, color=color.red, title="ADX Value MM_Method", display = display.data_window)
hline(25)

// Calcolo Win/Rate %
win_rate = (strategy.wintrades / strategy.closedtrades) * 100
plot(win_rate, title="% Win Rate", display = display.data_window)

// Get the biggest max Win/Loss Ration value from all of the closed trades.
maxWinLossRatio() =>
    var maxWinLossRatio = 0.0
    skipFirstCalculation = false
    skipFirstCalculation := strategy.closedtrades > StartAfterClosedTrades ? true : false
    if skipFirstCalculation == true
        for tradeNo = 0 to strategy.closedtrades - 1
            maxWinLossRatio := math.max(maxWinLossRatio, win_rate[tradeNo])
            result = maxWinLossRatio
plot(maxWinLossRatio(), "% Max Win/Loss Ratio", display = display.data_window)

 // Get the lowest min Win/Loss Ration value from all of the closed trades.
minWinLossRatio() =>
    var minWinLossRatio = 100
    skipFirstCalculation = false
    skipFirstCalculation := strategy.closedtrades > StartAfterClosedTrades ? true : false
    if skipFirstCalculation == true
        for tradeNo = 0 to strategy.closedtrades - 1
            minWinLossRatio := math.min(minWinLossRatio, win_rate[tradeNo])
            result = minWinLossRatio
plot(minWinLossRatio(), "% Min Win/Loss Ratio", display = display.data_window)

// // Start checking if last trade was lost
// var lastTradeWasLoss = false
// if (strategy.losstrades[0] > strategy.losstrades[1])
//     // // last trade was a loss
//     lastTradeWasLoss := true
// if (strategy.wintrades[0] > strategy.wintrades[1])
//     // // successful trade, reset
//     lastTradeWasLoss := false
// plotshape(MM_Method == 24 or MM_Method == 25 ? lastTradeWasLoss : na, title="Last Trade Was Loss", color=color.red)
// bgcolor((MM_Method == 24 or MM_Method == 25) and lastTradeWasLoss == 1 ? color.red : lastTradeWasLoss == 0 ? color.green : na, transp=90)

// // Debug last Trade Was Loss "It Swithes from 0 to 1 everytime the entire strip changes from win to loss"
// // if strategy.closedtrades != strategy.closedtrades[1]
// //     log.info(str.tostring(lastTradeWasLoss), "lastTradeWasLoss")
// // End checking if last trade was lost

// // Counter Win And Lost Trades
var countLostTrades = 0
var countWonTrades = 0
if (strategy.losstrades[0] > strategy.losstrades[1])
    countLostTrades := countLostTrades - 1
else if (strategy.wintrades[0] > strategy.wintrades[1])
    countLostTrades := 0
if (strategy.wintrades[0] > strategy.wintrades[1])
    countWonTrades := countWonTrades + 1
else if (strategy.losstrades[0] > strategy.losstrades[1])
    countWonTrades := 0
plot(countLostTrades, title="Count Lost Trades", color=color.red, display = display.data_window)
plot(countWonTrades, title="Count Won Trades", color=color.green, display = display.data_window)
plotshape(MM_Method == 24 or MM_Method == 25 ? countLostTrades : na, title="Count Lost Trades Plotshape", color=color.red)
plotshape(MM_Method == 24 or MM_Method == 25 ? countWonTrades : na, title="Count Won Trades Plotashape", color=color.green)

// // Debug count Lost Trades E count Won Trades One By One
// if strategy.closedtrades != strategy.closedtrades[1] and countLostTrades != 0
//     log.info(str.tostring(countLostTrades), "countLostTrades")
// if strategy.closedtrades != strategy.closedtrades[1] and countWonTrades != 0
//     log.info(str.tostring(countWonTrades), "countWonTrades")


/////////////////////////////////////////////////////////////// Start Strips Win/Loss Max Trades Plotter. It returns the maximum of the strip. ///////////////////////////////////////////////////////////////

//////////////////////// Start Bar Index Returns the bar index at the beginning/end of the strip. Not Needed "keep commented". ////////////////////////
// plot(bar_index, title="Bar Index")

// var startBarIndex = 0.0
// if countLostTrades[0] < 0 and countLostTrades[1] == 0
//     startBarIndex := bar_index
// plot(startBarIndex, title="Start Bar Index")
// plotshape(countLostTrades[0] < 0 and countLostTrades[1] == 0, title="Start Bar Index Plotshape", color=color.green, size=size.normal)

// var endBarIndex = 0.0
// if countWonTrades[0] > 0 and countWonTrades[1] == 0
//     endBarIndex := bar_index
// plot(endBarIndex, title="End Bar Index")
// plotshape(countWonTrades[0] > 0 and countWonTrades[1] == 0, title="End Bar Index Plotshape", color=color.red, size=size.normal)
//////////////////////// End Bar Index Returns the bar index at the beginning/end of the strip. Not Needed "keep commented". ////////////////////////


maxStripWonTrades = 0
if countLostTrades[0] < 0 and countLostTrades[1] == 0
    maxStripWonTrades := countWonTrades[1]
plot(maxStripWonTrades, title="Max Strip Won Trades", display = display.data_window)
plotshape((MM_Method == 24 or MM_Method == 25) and countLostTrades[0] < 0 and countLostTrades[1] == 0 ? countLostTrades[0] < 0 and countLostTrades[1] == 0 : na, title="Start Bar Index Plotshape", color=color.green, size=size.normal)

maxStripLostTrades = 0
if countWonTrades[0] > 0 and countWonTrades[1] == 0
    maxStripLostTrades := countLostTrades[1]
plot(maxStripLostTrades, title="Max Strip Lost Trades", display = display.data_window)
plotshape((MM_Method == 24 or MM_Method == 25) and countWonTrades[0] > 0 and countWonTrades[1] == 0 ? countWonTrades[0] > 0 and countWonTrades[1] == 0 : na, title="End Bar Index Plotshape", color=color.red, size=size.normal)


// // // Debug Start Strips Win/Loss Max Trades Plotter.
if (MM_Method == 24 and maxStripWonTrades != 0) or (MM_Method == 25 and maxStripWonTrades != 0)
    log.info(str.tostring(maxStripWonTrades), "Max Strip Won Trades")
//    log.info("\nMax Strip Won Trades : {0}" , str.tostring(maxStripWonTrades))      // More detailed logs !!!
if (MM_Method == 24 and maxStripLostTrades != 0) or (MM_Method == 25 and maxStripLostTrades != 0)
    log.info(str.tostring(maxStripLostTrades), "Max Strip Lost Trades")
//    log.info("\nMax Strip Lost Trades : {0}" , str.tostring(maxStripLostTrades))    // More detailed logs !!!


/////////////////////////////////////////////////////////////// End Strips Win/Loss Max Trades Plotter. It returns the maximum of the strip. ///////////////////////////////////////////////////////////////

Balance = (InitialCapital + strategy.netprofit)

FixedEntryPercentSize = (((InitialCapital) * EntryCapitalPercent) / 100) / close
EntryBalancePercent = (((InitialCapital + strategy.netprofit) * EntryCapitalPercent) / 100) / close
EntryMonetaryRisk = ((InitialCapital * EntryCapitalPercent) / 100) / StopLossPercent  * 100  / close
plot(MM_Method == 3 ? EntryMonetaryRisk : na, title="Entry Monetary Risk", display = display.data_window)
EntryMonetaryRiskBalancePercent = ((Balance * EntryCapitalPercent) / 100) / StopLossPercent  * 100  / close
EntryAtrCapitalRisk = (InitialCapital * EntryCapitalPercent / ATRValue) / close // E' un'alternativa all'originale: (InitialCapital * EntryCapitalPercent / 100)  / (ATRValue * close) perchè se il capitale è piccolo entra con poco.
EntryAtrCapitalRiskBalancePercent = (Balance * EntryCapitalPercent / ATRValue) / close  // E' un'alternativa all'originale: (Balance * EntryCapitalPercent / 100)  / (ATRValue * close) perchè se il capitale è piccolo entra con poco.
EntryAtrCapitalRiskOrig = (InitialCapital * EntryCapitalPercent / 100)  / (ATRValue * close)
EntryAtrCapitalRiskBalancePercentOrig = (Balance * EntryCapitalPercent / 100)  / (ATRValue * close)
EntryAdxCapitalRisk = (InitialCapital * EntryCapitalPercent / adx) / close // E' un'alternativa all'originale: (InitialCapital * EntryCapitalPercent / 100)  / (adx * close) perchè se il capitale è piccolo entra con poco.
EntryAdxCapitalRiskBalancePercent = (Balance * EntryCapitalPercent / adx) / close // E' un'alternativa all'originale: (Balance * EntryCapitalPercent / 100)  / (adx * close) perchè se il capitale è piccolo entra con poco.
EntryAdxCapitalRiskOrig = (InitialCapital * EntryCapitalPercent / 100)  / (adx * close)
EntryAdxCapitalRiskBalancePercentOrig = (Balance * EntryCapitalPercent / 100)  / (adx * close)
EntryCapitalPercentFMaxLoss = ((((InitialCapital) * EntryCapitalPercent) / 100) / WorstLossRealized)
plot(MM_Method == 15 ? EntryCapitalPercentFMaxLoss : na, title="Entry Capital Percent F Max Loss", display = display.data_window)
EntryBalancePercentFMaxLoss = ((((Balance) * EntryCapitalPercent) / 100) / WorstLossRealized)
plot(MM_Method == 16 ? EntryBalancePercentFMaxLoss : na, title="Entry Balance Percent F Max Loss", display = display.data_window)
EntryCapitalPercentFStopLoss = ((((InitialCapital) * EntryCapitalPercent) / 100) / Monetary_Risk)
plot(MM_Method == 17 ? EntryCapitalPercentFStopLoss : na, title="Entry Capital Percent F Stop Loss", display = display.data_window)
EntryBalancePercentFStopLoss = ((((Balance) * EntryCapitalPercent) / 100) / Monetary_Risk)
plot(MM_Method == 18 ? EntryBalancePercentFStopLoss : na, title="Entry Balance Percent F Stop Loss", display = display.data_window)
EntryCapitalPercentFMaxDDMonetaryLoss = ((((InitialCapital) * EntryCapitalPercent) / 100) / MaxDDMonetaryLoss) // Il Max Drawdown Absolute $ sarà la percentuale di rischio da noi scelta. I valori input MaxDDMonetaryLoss sono stati presi precedentemente con ingresso semplice ad 1 contratto.
plot(MM_Method == 19 ? EntryCapitalPercentFMaxDDMonetaryLoss : na, title="Entry Capital Percent F Max DD Monetary Loss", display = display.data_window)
EntryBalancelPercentFMaxDDMonetaryLoss = ((((Balance) * EntryCapitalPercent) / 100) / MaxDDMonetaryLoss) // Il Max Drawdown Absolute $ non sarà la percentuale di rischio da noi scelta perchè questa volta stiamo usando il Balance. I valori input MaxDDMonetaryLoss sono stati presi precedentemente con ingresso semplice ad 1 contratto.
plot(MM_Method == 20 ? EntryBalancelPercentFMaxDDMonetaryLoss : na, title="Entry Balance Percent F Max DD Monetary Loss", display = display.data_window)


// // Get the biggest max trade drawdown value from all of the closed trades.
// maxTradeDrawDown() =>
//     maxDrawdown = 0.0
//     for tradeNo = 0 to strategy.closedtrades - 1
//         maxDrawdown := math.max(maxDrawdown, strategy.closedtrades.max_drawdown(tradeNo))
//     result = maxDrawdown
// plot(maxTradeDrawDown(), "Biggest max drawdown")

// // Actual Equity (FUNZIONA)
// InitialCapital = input.float(defval = 1000, title="Initial Capital", group="Capital Management", step=0.1)
// Balance = (InitialCapital + strategy.netprofit)
// plot(InitialCapital + strategy.netprofit, title="Actual Equity")

// // Highest Equity (FUNZIONA)
// // GetEquityHigh() returns the highest equity that the strategy
// // achieved during its backtest and subsequent real-time signals.
// // Note: for accuracy call this function on every bar.
GetEquityHigh() =>
    var highestEquity = strategy.initial_capital
    highestEquity := math.max(highestEquity, (InitialCapital + strategy.netprofit))
plot(GetEquityHigh(), "Highest Equity", display = display.data_window)

// Max Drawdown Absolute $ (FUNZIONA)
maxDrawdown = (strategy.max_drawdown/strategy.initial_capital * 1000)
plot(maxDrawdown, title="Max Drawdown Absolute $", display = display.data_window)

// Massimo DD In %
maxDrawdownPercent = ta.max(strategy.max_drawdown*100/(GetEquityHigh()))
plot(maxDrawdownPercent, title="Max Drawdown Percent", display = display.data_window)

// Max Drawdown Percent Calculator
maxDrawdownPercentPlotter = ((- maxDrawdownPercent) * MaxDrawdownPercentCalculator) / 100
plot(maxDrawdownPercentPlotter, title="Max Drawdown Percent Calculator", display = display.data_window)

// Drawdown Relativo In $
relativeDrawdownMonetary = Balance - GetEquityHigh()
plot(relativeDrawdownMonetary, title="Relative Drawdown $", display = display.data_window)

// Drawdown Relativo In %
relativeDrawdownPercent = (relativeDrawdownMonetary / GetEquityHigh()) * 100
plot(relativeDrawdownPercent, title="Relative Drawdown Percent", display = display.data_window)


                                                                       // New calculation Open Balance for swing position strips, it didn't work without open balance //

openCommission = (strategy.opentrades.commission((strategy.opentrades - 1)))
//plot(openCommission, title="Open Commission")

BalanceWithOpenProfit = Balance + strategy.openprofit
//plot(BalanceWithOpenProfit, title="Balance With Open Profit")

OpenBalance = BalanceWithOpenProfit - openCommission
plot(OpenBalance, title="Open Balance", display = display.data_window)

// // Drawdown Relativo In $
relativeDrawdownMonetaryOB = OpenBalance - GetEquityHigh()
plot(relativeDrawdownMonetaryOB, title="Open Relative Drawdown $", display = display.data_window)

// Drawdown Relativo In %
relativeDrawdownPercentOB = (relativeDrawdownMonetaryOB / GetEquityHigh()) * 100
plot(relativeDrawdownPercentOB, title="Open Relative Drawdown Percent", display = display.data_window)


// //////////////// Start Plotshape Closed Balance
// plotshape(relativeDrawdownPercent <= StartFirstStrip and relativeDrawdownPercent >= EndFirstStrip ? relativeDrawdownPercent : na, size=size.small, color=color.yellow)
// plotshape(relativeDrawdownPercent <= (StartSecondStrip + 0.01) and relativeDrawdownPercent >= EndSecondStrip ? relativeDrawdownPercent : na, size=size.small, color=color.orange)
// plotshape(relativeDrawdownPercent <= (StartThirdStrip + 0.01) and relativeDrawdownPercent >= EndThirdStrip ? relativeDrawdownPercent : na, size=size.small, color=color.red)

// //////////////// MM_Method == 14 ingresso con size minore all'aumentare del DD, qui il relative drawdown % è calcolato sull'closed balance. L'ingresso è in % al balance. "Non funziona sullo swing di posizione"
// EntryBalancePercentRelativeDDPerc = 0.0
// if relativeDrawdownPercent <= StartFirstStrip and relativeDrawdownPercent >= EndFirstStrip // Example: 70 % to 80% of Max DD "First Strip"
//     EntryBalancePercentRelativeDDPerc := (((Balance) * SizePercentFirstStrip) / 100) / close // Example Entry: 90 % EntryCapitalPercent "First Strip"
// else if relativeDrawdownPercent <= (StartSecondStrip + 0.01) and relativeDrawdownPercent >= EndSecondStrip // Example: 80 % to 90 % of Max DD "Second Strip"
//     EntryBalancePercentRelativeDDPerc := (((Balance) * SizePercentSecondStrip) / 100) / close // Example Entry: 80 % EntryCapitalPercent "Second Strip"
// else if relativeDrawdownPercent <= (StartThirdStrip + 0.01) and relativeDrawdownPercent >= EndThirdStrip // Example: 90 to 100 % of Max DD "Third Strip"
//     EntryBalancePercentRelativeDDPerc := (((Balance) * SizePercentThirdStrip) / 100) / close // Example Entry: 70 % EntryCapitalPercent "Third Strip"
// else
//     EntryBalancePercentRelativeDDPerc := (((Balance) * EntryCapitalPercent) / 100) / close // Entry 100 % EntryCapitalPercent
// //////////////// End Plotshape Closed Balance

// //////////////// Plotshape Open Balance
plotshape((MM_Method == 13 or MM_Method == 14) and relativeDrawdownPercentOB <= StartFirstStrip and relativeDrawdownPercentOB >= EndFirstStrip ? relativeDrawdownPercentOB : na, size=size.small, color=color.yellow, title="First Strip")
plotshape((MM_Method == 13 or MM_Method == 14) and relativeDrawdownPercentOB <= (StartSecondStrip - 0.00001) and relativeDrawdownPercentOB >= EndSecondStrip ? relativeDrawdownPercentOB : na, size=size.small, color=color.orange, title="Second Strip")
plotshape((MM_Method == 13 or MM_Method == 14) and relativeDrawdownPercentOB <= (StartThirdStrip - 0.00001) and relativeDrawdownPercentOB >= EndThirdStrip ? relativeDrawdownPercentOB : na, size=size.small, color=color.red, title="Third Strip")

// //////////////// MM_Method == 13 ingresso con size minore all'aumentare del DD, qui il relative drawdown % è calcolato sull'open balance. L'ingresso è in % al capitale iniziale. "Funziona anche con lo swing di posizione".
EntryCapitalPercentRelativeDDPerc = 0.0
if relativeDrawdownPercentOB <= StartFirstStrip and relativeDrawdownPercentOB >= EndFirstStrip // Example: 70 % to 80% of Max DD "First Strip"
    EntryCapitalPercentRelativeDDPerc := (((InitialCapital) * SizePercentFirstStrip) / 100) / close // Example Entry: 90 % EntryCapitalPercent "First Strip"
else if relativeDrawdownPercentOB <= (StartSecondStrip - 0.00001) and relativeDrawdownPercentOB >= EndSecondStrip // Example: 80 % to 90 % of Max DD "Second Strip"
    EntryCapitalPercentRelativeDDPerc := (((InitialCapital) * SizePercentSecondStrip) / 100) / close // Example Entry: 80 % EntryCapitalPercent "Second Strip"
else if relativeDrawdownPercentOB <= (StartThirdStrip - 0.00001) and relativeDrawdownPercentOB >= EndThirdStrip // Example: 90 to 100 % of Max DD "Third Strip"
    EntryCapitalPercentRelativeDDPerc := (((InitialCapital) * SizePercentThirdStrip) / 100) / close // Example Entry: 70 % EntryCapitalPercent "Third Strip"
else
    EntryCapitalPercentRelativeDDPerc := (((InitialCapital) * EntryCapitalPercent) / 100) / close // Entry 100 % EntryCapitalPercent

// //////////////// MM_Method == 14 ingresso con size minore all'aumentare del DD, qui il relative drawdown % è calcolato sull'open balance. L'ingresso è in % al capitale del balance. "Funziona anche con lo swing di posizione".
EntryBalancePercentRelativeDDPerc = 0.0
if relativeDrawdownPercentOB <= StartFirstStrip and relativeDrawdownPercentOB >= EndFirstStrip // Example: 70 % to 80% of Max DD "First Strip"
    EntryBalancePercentRelativeDDPerc := (((Balance) * SizePercentFirstStrip) / 100) / close // Example Entry: 90 % EntryCapitalPercent "First Strip"
else if relativeDrawdownPercentOB <= (StartSecondStrip - 0.00001) and relativeDrawdownPercentOB >= EndSecondStrip // Example: 80 % to 90 % of Max DD "Second Strip"
    EntryBalancePercentRelativeDDPerc := (((Balance) * SizePercentSecondStrip) / 100) / close // Example Entry: 80 % EntryCapitalPercent "Second Strip"
else if relativeDrawdownPercentOB <= (StartThirdStrip - 0.00001) and relativeDrawdownPercentOB >= EndThirdStrip // Example: 90 to 100 % of Max DD "Third Strip"
    EntryBalancePercentRelativeDDPerc := (((Balance) * SizePercentThirdStrip) / 100) / close // Example Entry: 70 % EntryCapitalPercent "Third Strip"
else
    EntryBalancePercentRelativeDDPerc := (((Balance) * EntryCapitalPercent) / 100) / close // Entry 100 % EntryCapitalPercent


// Start Entry Fixed Ratio MM_Method == 21 //
// (Imposta Input FixedContracts E Ratio E Fixed Ratio Contract Decimals E Truncate)
EntryFixedRatio = 0.0
RatioCalculation = 1 + 8 * strategy.netprofit / Ratio
// Contratti Senza Decimali //
if RatioCalculation > 0 and FixedRationContractDecimals == "1"
    EntryFixedRatio := FixedContracts * int (0.5 * (1 + math.sqrt(RatioCalculation)) / FixedContracts)
//  EntryFixedRatio := FixedContracts *     (0.5 * (1 + math.sqrt(RatioCalculation)) / FixedContracts)


// Diviso 10 Dall'originale per tradare size minori di un contratto, E con Truncate ESEGUE STEP DA 0.1 A 0.2 ETC... ATTENZIONE SOLO CON SIZE AD 1 DECIMALE: 0.1, 0.2 ETC ... IMPOSTA TRUNCATE A 1 E FixedRationContractDecimals A SECONDA DEI DECIMALI UTILIZZATI
if RatioCalculation > 0 and FixedRationContractDecimals == "0.1"
    EntryFixedRatio := FixedContracts *  (0.5 * (1 + math.sqrt(RatioCalculation)) / FixedContracts)  / 10 //
    EntryFixedRatio := Truncate(EntryFixedRatio, inTruncate)
// Diviso 100 e un'altro int aggiunto Dall'originale per tradare size minori di un contratto, ESEGUE STEP DA 0.01, 0.02, 0.03 ETC... ATTENZIONE SOLO CON SIZE AD 2 DECIMALI: 0.01, 0.02 ETC ... IMPOSTA TRUNCATE A 2 E FixedRationContractDecimals A SECONDA DEI DECIMALI UTILIZZATI
if RatioCalculation > 0 and FixedRationContractDecimals == "0.01"
    EntryFixedRatio := FixedContracts * int (0.5 * int (1 + math.sqrt(RatioCalculation)) / FixedContracts) / 100
    EntryFixedRatio := Truncate(EntryFixedRatio, inTruncate)
// Diviso 1000 e un'altro int aggiunto Dall'originale per tradare size minori di un contratto, ESEGUE STEP DA 0.001, 0.002, 0.003 ETC... ATTENZIONE SOLO CON SIZE AD 2 DECIMALI: 0.001, 0.002 ETC ... IMPOSTA TRUNCATE A 3 E FixedRationContractDecimals A SECONDA DEI DECIMALI UTILIZZATI
if RatioCalculation > 0 and FixedRationContractDecimals == "0.001"
    EntryFixedRatio := FixedContracts * int (0.5 * int (1 + math.sqrt(RatioCalculation)) / FixedContracts) / 1000
    EntryFixedRatio := Truncate(EntryFixedRatio, inTruncate)


if EntryFixedRatio < FixedContracts
    EntryFixedRatio := FixedContracts
plot(MM_Method == 21 ? EntryFixedRatio : na, title="Entry Fixed Ratio", display = display.data_window)
// End Entry Fixed Ratio //


// Start Entry Fixed Ratio Debug //
// Per effettuare il Debug, inserire: EntryFixedRatioDubug in qty = EntryFixedRatioDubug della strategia e verificare le altre size se rispettano i decimali minori !!! .
EntryFixedRatioDubug = 0.0
RatioCalculationDubug = 1 + 8 * strategy.netprofit / Ratio
// Contratti Senza Decimali //
if RatioCalculationDubug > 0
    EntryFixedRatioDubug := FixedRatioContractsDebug * int (0.5 * (1 + math.sqrt(RatioCalculationDubug)) / FixedRatioContractsDebug)
//  EntryFixedRatio := FixedContractsDebug *     (0.5 * (1 + math.sqrt(RatioCalculation)) / FixedContractsDebug)

if EntryFixedRatioDubug < FixedRatioContractsDebug
    EntryFixedRatioDubug := FixedRatioContractsDebug
plot(MM_Method == 21 ? EntryFixedRatioDubug : na, title="Entry Fixed Ratio Dubug", display = display.data_window)
// End Entry Fixed Ratio Debug //


// EntryCapitalPercentWinLossRatio Calculation MM_Method == 22
EntryCapitalPercentWinLossRatio = 0.0
if strategy.closedtrades <= StartAfterClosedTrades or strategy.closedtrades > StartAfterClosedTrades and (win_rate > WinLossPercentageInf and win_rate < WinLossPercentageSup)
    EntryCapitalPercentWinLossRatio := FixedEntryPercentSize                                       // Debug 1 contratto
if strategy.closedtrades > StartAfterClosedTrades and win_rate >= WinLossPercentageSup
    EntryCapitalPercentWinLossRatio := ((InitialCapital * SizeWinLossPercentageSup) / 100) / close // Debug 2 contratti
if strategy.closedtrades > StartAfterClosedTrades and win_rate <= WinLossPercentageInf
    EntryCapitalPercentWinLossRatio := ((InitialCapital * SizeWinLossPercentageInf) / 100) / close // Debug 3 contratti

// EntryBalancePercentWinLossRatio Calculation MM_Method == 23
EntryBalancePercentWinLossRatio = 0.0
if strategy.closedtrades <= StartAfterClosedTrades or strategy.closedtrades > StartAfterClosedTrades and (win_rate > WinLossPercentageInf and win_rate < WinLossPercentageSup)
    EntryBalancePercentWinLossRatio := EntryBalancePercent                                         // Debug 1 contratto
if strategy.closedtrades > StartAfterClosedTrades and win_rate >= WinLossPercentageSup
    EntryBalancePercentWinLossRatio := ((Balance * SizeWinLossPercentageSup) / 100) / close        // Debug 2 contratti
if strategy.closedtrades > StartAfterClosedTrades and win_rate <= WinLossPercentageInf
    EntryBalancePercentWinLossRatio := ((Balance * SizeWinLossPercentageInf) / 100) / close        // Debug 3 contratti

plotshape((MM_Method == 22 or MM_Method == 23) and strategy.closedtrades > StartAfterClosedTrades and win_rate >= WinLossPercentageSup ? true : na, size=size.small, color=color.green, title="Win Loss Percentage =Sup")
plotshape((MM_Method == 22 or MM_Method == 23) and strategy.closedtrades > StartAfterClosedTrades and win_rate <= WinLossPercentageInf ? true : na, size=size.small, color=color.red, title="Win Loss Percentage =Inf")


// Start Position Size Calculation
openProfit = strategy.opentrades.profit(0)
plot(openProfit, title = "Open Profit", display = display.data_window)

// Entry Capital Percent MM_Method 24
EntryCapitalPercentZ_Score = countWonTrades == MaxPositiveStrips and MaxPositiveStrips != 0 and strategy.opentrades == 0 ? (((InitialCapital) * EntryCapitalPercentZScorePositiveStrips) / 100) / close : // Consecutive Win Trades // Debug 10 Contracts
     countLostTrades == - MaxNegativeStrips and MaxNegativeStrips != 0 and strategy.opentrades == 0 ? (((InitialCapital) * EntryCapitalPercentZScoreNegativeStrips) / 100) / close : // Consecutive Lost Trades // Debug 5 Contracts
         countWonTrades != MaxPositiveStrips and strategy.opentrades == 0 ? (((InitialCapital) * EntryCapitalPercentZScore) / 100) / close :            // Normal Capital % Entry // Debug 24 Contracts
             countLostTrades != - MaxNegativeStrips and strategy.opentrades == 0 ? (((InitialCapital) * EntryCapitalPercentZScore) / 100) / close :     // Normal Capital % Entry // Debug 24 Contracts
                 countLostTrades == (- MaxNegativeStrips + 1) and openProfit < 0 ? (((InitialCapital) * EntryCapitalPercentZScoreNegativeStrips) / 100) / close :       // Consecutive Lost Trades Per lo swing di posizione // Debug 5 Contracts
                     countWonTrades == (MaxPositiveStrips - 1) and openProfit > 0 ? (((InitialCapital) * EntryCapitalPercentZScorePositiveStrips) / 100) / close :     // Consecutive Win Trades Per lo swing di posizione // Debug 10 Contracts
                 (((InitialCapital) * EntryCapitalPercentZScore) / 100) / close

// Entry Balance Percent MM_Method 25
EntryBalancePercentZ_Score = countWonTrades == MaxPositiveStrips and MaxPositiveStrips != 0 and strategy.opentrades == 0 ? (((Balance) * EntryCapitalPercentZScorePositiveStrips) / 100) / close : // Consecutive Win Trades // Debug 10 Contracts
     countLostTrades == - MaxNegativeStrips and MaxNegativeStrips != 0 and strategy.opentrades == 0 ? (((Balance) * EntryCapitalPercentZScoreNegativeStrips) / 100) / close : // Consecutive Lost Trades // Debug 5 Contracts
         countWonTrades != MaxPositiveStrips and strategy.opentrades == 0 ? (((Balance) * EntryCapitalPercentZScore) / 100) / close :            // Normal Capital % Entry // Debug 24 Contracts
             countLostTrades != - MaxNegativeStrips and strategy.opentrades == 0 ? (((Balance) * EntryCapitalPercentZScore) / 100) / close :     // Normal Capital % Entry // Debug 24 Contracts
                 countLostTrades == (- MaxNegativeStrips + 1) and openProfit < 0 ? (((Balance) * EntryCapitalPercentZScoreNegativeStrips) / 100) / close :       // Consecutive Lost Trades Per lo swing di posizione // Debug 5 Contracts
                     countWonTrades == (MaxPositiveStrips - 1) and openProfit > 0 ? (((Balance) * EntryCapitalPercentZScorePositiveStrips) / 100) / close :     // Consecutive Win Trades Per lo swing di posizione // Debug 10 Contracts
                 (((Balance) * EntryCapitalPercentZScore) / 100) / close
// End Position Size Calculation



posSize = 0.0

if (MM_Method == 0)                                           // Contratti Fissi (Imposta Input FixedContracts) //
    posSize := FixedContracts
else if (MM_Method == 1)                                      // Monetario Fisso In Percentuale Al Capitale Iniziale (Imposta Input EntryCapitalPercent) //
    posSize := FixedEntryPercentSize
else if (MM_Method == 2)                                      // Monetario In Percentuale Al Balance (Imposta Input EntryCapitalPercent) //
    posSize := EntryBalancePercent
else if (MM_Method == 3)                                      // Rischio Monetario Fisso In Percentuale Al Capitale Iniziale (Imposta Imput EntryCapitalPercent E Stop Loss Percent MM_Method)
    posSize := EntryMonetaryRisk
else if (MM_Method == 4)                                      // Rischio Monetario Fisso In Percentuale Al Balance (Imposta Input EntryCapitalPercent E Stop Loss Percent MM_Method)
    posSize := EntryMonetaryRiskBalancePercent
else if (MM_Method == 5)                                      // Atr In % Al Rischio Del Capitale Iniziale (Imposta Input EntryCapitalPercent E Period_ATR E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if ATRValue > 0
        posSize := EntryAtrCapitalRisk
else if (MM_Method == 6)                                      // Atr In % Al Rischio Del Balance (Imposta Input EntryCapitalPercent E Period_ATR E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if ATRValue > 0
        posSize := EntryAtrCapitalRiskBalancePercent
else if (MM_Method == 7)                                      // Atr In % Al Rischio Del Capitale Iniziale Orig (Imposta Input EntryCapitalPercent E Period_ATR E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if (ATRValue * close) > 0
        posSize := EntryAtrCapitalRiskOrig
else if (MM_Method == 8)                                      // Atr In % Al Rischio Del Balance Orig (Imposta Input EntryCapitalPercent E Period_ATR E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if (ATRValue * close) > 0
        posSize := EntryAtrCapitalRiskBalancePercentOrig
else if (MM_Method == 9)                                      // Adx In % Al Rischio Del Capitale Iniziale (Imposta Input EntryCapitalPercent E DI Length E ADX Smoothing E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if adx > 0
        posSize := EntryAdxCapitalRisk
else if (MM_Method == 10)                                     // Adx In % Al Rischio Del Balance (Imposta Input EntryCapitalPercent E DI Length E ADX Smoothing E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if adx > 0
        posSize := EntryAdxCapitalRiskBalancePercent
else if (MM_Method == 11)                                    // Adx In % Al Rischio Del Capitale Iniziale Orig (Imposta Input EntryCapitalPercent E DI Length E ADX Smoothing E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if (adx * close) > 0
        posSize := EntryAdxCapitalRiskOrig
else if (MM_Method == 12)                                    // Adx In % Al Rischio Del Balance Orig (Imposta Input EntryCapitalPercent E DI Length E ADX Smoothing E OnOffContractBalancePerc E MaxcontractBalancePerc)
    if (adx * close) > 0
        posSize := EntryAdxCapitalRiskBalancePercentOrig
else if (MM_Method == 13)                                    // Monetario In Percentuale Al Capitale Iniziale Diviso In Fasce Su EntryCapitalPercent In Base Alle Fasce Max DD % (Imposta EntryCapitalPercent E Start End Strip E Size Strip)
    posSize := EntryCapitalPercentRelativeDDPerc
else if (MM_Method == 14)                                    // Monetario In Percentuale Al Balance Diviso In Fasce Su EntryCapitalPercent In Base Alle Fasce Max DD % (Imposta EntryCapitalPercent E Start End Strip E Size Strip)
    posSize := EntryBalancePercentRelativeDDPerc
else if (MM_Method == 15)                                    // Monetario Fisso In Percentuale Al Capitale Iniziale Proporzionato Alla Massima Perdita Monetaria " Percent F Capitale Iniziale Max Loss " (Imposta Imput EntryCapitalPercent E Worst Loss Realized)
    posSize := EntryCapitalPercentFMaxLoss
else if (MM_Method == 16)                                    // Monetario Fisso In Percentuale Al Balance Proporzionato Alla Massima Perdita Monetaria " Percent F Balance Max Loss " (Imposta Imput EntryCapitalPercent E Worst Loss Realized)
    posSize := EntryBalancePercentFMaxLoss
else if (MM_Method == 17)                                    // Monetario Fisso In Percentuale Al Capitale Iniziale Proporzionato Allo Stop Loss Monetario " Percent F Capitale Iniziale Stop Loss Monetario " (Imposta Imput EntryCapitalPercent E Monetary_Risk E OnOffContractBalancePerc E MaxcontractBalancePerc)
    posSize := EntryCapitalPercentFStopLoss
else if (MM_Method == 18)                                    // Monetario Fisso In Percentuale Al Balance Proporzionato Allo Stop Loss Monetario " Percent F Balance Stop Loss Monetario " (Imposta Imput EntryCapitalPercent E Monetary_Risk E OnOffContractBalancePerc E MaxcontractBalancePerc)
    posSize := EntryBalancePercentFStopLoss
else if (MM_Method == 19)                                    // Monetario Fisso In Percentuale Al Capitale Iniziale Proporzionato Al Massimo DD Monetario " Percent F Capitale Iniziale Max DD Monetario " (Imposta Imput EntryCapitalPercent E Max DD Monetary Loss E OnOffContractBalancePerc E MaxcontractBalancePerc)
    posSize := EntryCapitalPercentFMaxDDMonetaryLoss
else if (MM_Method == 20)                                    // Monetario Fisso In Percentuale Al Balance Proporzionato Al Massimo DD Monetario " Percent F Balance Max DD Monetario " (Imposta Imput EntryCapitalPercent E Max DD Monetary Loss E OnOffContractBalancePerc E MaxcontractBalancePerc)
    posSize := EntryBalancelPercentFMaxDDMonetaryLoss
else if (MM_Method == 21)                                    // Monetario Fisso A Step Decisi Dal Delta Sul Sul Balance Raggiunto "Entry Fixed Ratio" (Imposta Input FixedContracts E Ratio E Fixed Ratio Contract Decimals E Truncate)
    posSize := EntryFixedRatio
else if (MM_Method == 22)                                    // Monetario In Percentuale Al Capitale Iniziale Win/Loss Ratio (Imposta Input EntryCapitalPercent E Start After Closed Trades E Win Loss Percentage Sup/Inf E Size Win Loss Percentage =Sup/=Inf)
    posSize := EntryCapitalPercentWinLossRatio
else if (MM_Method == 23)                                    // Monetario In Percentuale Al Balance Win/Loss Ratio (Imposta Input EntryCapitalPercent E Start After Closed Trades E Win Loss Percentage Sup/Inf E Size Win Loss Percentage =Sup/=Inf)
    posSize := EntryBalancePercentWinLossRatio
if (MM_Method == 24)                                         // Monetario In Percentuale Al Capitale Iniziale Win/Loss Z-Score (Imposta Input Entry Capital Percent Z Score E Entry Capital Percent Z Score Positive/Negative Strips E Max Positive/Negative Strips)
    posSize := EntryCapitalPercentZ_Score
if (MM_Method == 25)                                         // Monetario In Percentuale Al Balance Win/Loss Z-Score (Imposta Input Entry Capital Percent Z Score E Entry Capital Percent Z Score Positive/Negative Strips E Max Positive/Negative Strips)
    posSize := EntryBalancePercentZ_Score

// Round Position Size
if RoundPositionSize == true
    posSize := math.round(posSize)

// Do not execeed over the max size
MaxSizeBalcePerc = ((Balance * MaxcontractBalancePerc) / 100) / close
plot(MaxSizeBalcePerc, title="Max Size Balance Perc", display = display.data_window)

if posSize > Max_Contract and OnOffContractMaxMin == true and not OnOffContractBalancePerc
    posSize := Max_Contract
else if posSize > MaxSizeBalcePerc and OnOffContractBalancePerc == true and not OnOffContractMaxMin  // MaxSizeBalcePerc usato solo per Metodi che usano Atr e Adx siccome con la formula originale basata sul rischio capitale entrava con troppa poca size avendo capitali troppo bassi
    posSize := MaxSizeBalcePerc                                                                      // ho modificato la formula ma non faccio mai eccedere la size di ingresso con il mio massimo capitale del balance perchè tradingview non se ne rende conto e mi fa entrate anche con size oltre il capitale disponibile.
else if posSize < Min_Contract and OnOffContractMaxMin == true and not OnOffContractBalancePerc
    posSize := Min_Contract
else if OnOffContractMaxMin == true and OnOffContractBalancePerc == true
    posSize := 0.0

plot(posSize, title="Position Size MM_Method", display = display.data_window)
plot(InitialCapital + strategy.netprofit, title="Closed Balance", display = display.data_window)
plot(OnOffContractMaxMin == true and not OnOffContractBalancePerc ? Max_Contract: na, title="Max Contract", display = display.data_window)
plot(OnOffContractMaxMin == true and not OnOffContractBalancePerc ? Min_Contract: na, title="Min Contract", display = display.data_window)




// Monitoraggio posizione
bought = strategy.position_size[0]> strategy.position_size[1]
Close_TP = false
Close_TP := strategy.position_size[1] - strategy.position_size[0] and strategy.position_size[1] != 0 and strategy.position_size[0] != 0

plotshape(Close_TP,title="Close_TP", style=shape.xcross, color=color.blue, size =size.small, editable = true)
plot(strategy.position_size[1],"Position Old", display = display.data_window)
plot(strategy.position_size,"Position", display = display.data_window)


/////////////////////////////////////////////////////////////// Start Array's Table And Won/Loss Strips Counter ///////////////////////////////////
// Table Inputs
fattoreArrotondamento = input.int(1, "Fattore di arrotondamento",options = [1,10,100,1000,10000,100000, 1000000, 10000000], group="Array Table")
posizione = input.string("bottom_right", "posizione tabella", ["bottom_left", "bottom_center", "bottom_right", "middle_left", "middle_center", "middle_right", "top_left", "top_center" ,"top_right"], group="Array Table")
coloreBarreBullish = input.color(color.rgb(47, 159, 68), "Colore celle bullish", group="Array Table")
coloreBarreBearish = input.color(color.rgb(227, 65, 65), "Colore celle bearish", group="Array Table")
coloreSfondoTabella = input.color(color.rgb(53, 61, 68), "Colore sfondo tabella", group="Array Table")
coloreEtichetteSfondo = input.color(color.rgb(19, 50, 70), "Colore sfondo etichetta", group="Array Table")
coloreEtichetteTesto = input.color(color.rgb(255, 255, 255), "Colore testo etichetta", group="Array Table")
dimensioneTesto = input.string("small", "Dimensione Carattere", options=["tiny", "small", "normal", "large", "huge"], group="Array Table")

// Creating a table and cells
var tabellaInfo = table.new(position = posizione, columns = 100, rows = 100, bgcolor = coloreSfondoTabella)
table.cell(tabellaInfo, 0, 0, "MaxStripWonTrades", text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign= text.align_center)
table.cell(tabellaInfo, 0, 1, "MaxStripLostTrades", text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign= text.align_center)
table.cell(tabellaInfo, 0, 2, "MaxStripWonLostTrades", text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign= text.align_center)


// Count Total Won/Lost Strips
var contTotalStrips = 0
if maxStripWonTrades > 0
    contTotalStrips := contTotalStrips +1
if maxStripLostTrades < 0
    contTotalStrips := contTotalStrips +1
plot(contTotalStrips, title="Cont Total Strips", display = display.data_window)

// Count Total Won Strips
var contWonStrips = 0
if maxStripWonTrades > 0
    contWonStrips := contWonStrips +1
plot(contWonStrips, title="Cont Won Strips", display = display.data_window)

// Count Total Lost Strips
var contLostStrips = 0
if maxStripLostTrades < 0
    contLostStrips := contLostStrips +1
plot(contLostStrips, title="Cont Lost Strips", display = display.data_window)


// Creating three arrays to detect their size
var arrayTotalStrips = array.new_float(contTotalStrips, 0)
var arrayMaxStripWonTrades = array.new_float(contWonStrips, 0)
var arrayMaxStripLostTrades = array.new_float(contLostStrips, 0)

// Put a variable results into an array
if maxStripWonTrades != 0
    array.push(arrayMaxStripWonTrades, maxStripWonTrades)

if maxStripLostTrades != 0
    array.push(arrayMaxStripLostTrades, maxStripLostTrades)

if maxStripLostTrades != 0
    array.push(arrayTotalStrips, maxStripWonTrades)
    array.push(arrayTotalStrips, maxStripLostTrades)

// // Loop all the array size and display all the lenght on the screen with table.cell "arrayMaxStripWonTrades"
// for i=0 to array.size(arrayMaxStripWonTrades)-1
//     table.cell(tabellaInfo, i+1, 0, str.tostring(i), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)
table.cell(tabellaInfo, 2, 0, str.tostring(array.size(arrayMaxStripWonTrades)), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)
for i=0 to 0
    table.cell(tabellaInfo, i+1, 0, str.tostring(arrayMaxStripWonTrades), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)

// // Loop all the array size and display all the lenght on the screen with table.cell "arrayMaxStripLostTrades"
// for i=0 to array.size(arrayMaxStripLostTrades)-1
//    table.cell(tabellaInfo, i+1, 1, str.tostring(i), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)
table.cell(tabellaInfo, 2, 1, str.tostring(array.size(arrayMaxStripLostTrades)), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)
for i=0 to 0
    table.cell(tabellaInfo, i+1, 1, str.tostring(arrayMaxStripLostTrades), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)

// // Loop all the array size and display all the lenght on the screen with table.cell "arrayTotalStrips"
// for i=0 to array.size(arrayTotalStrips)-1
    // table.cell(tabellaInfo, i+1, 2, str.tostring(i), text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center
for i=0 to 0
    table.cell(tabellaInfo, i+1, 2, str.tostring("") + str.tostring(contTotalStrips) , text_color = coloreEtichetteTesto, text_size = dimensioneTesto, text_halign=text.align_center)

/////////////////////////////////////////////////////////////// End Array's Table And Won/Loss Strips Counter ///////////////////////////////////


/////////////////////////////////////////////////////////////// Start Change Size Z-Score Labels MM_Method 24/25 ///////////////////////////////////
// Create a label when size changes
ChangePositionSize_Z_Score =  countWonTrades == MaxPositiveStrips and MaxPositiveStrips != 0 and strategy.opentrades[1] == 0 and strategy.opentrades == 1 ? true :                                                               // No Swing Position
     countLostTrades == - MaxNegativeStrips and MaxNegativeStrips != 0 and strategy.opentrades[1] == 0 and strategy.opentrades == 1 ? true :                                                                     // No Swing Position
         countWonTrades == MaxPositiveStrips and MaxPositiveStrips != 0 and strategy.opentrades[1] == 1 and strategy.opentrades == 1 and strategy.position_size[1] != strategy.position_size ? true :            // Swing Position
             countLostTrades == - MaxNegativeStrips and MaxNegativeStrips != 0 and strategy.opentrades[1] == 1 and strategy.opentrades == 1 and strategy.position_size[1] != strategy.position_size ? true : na  // Swing Position

plotshape(MM_Method == 24 or MM_Method == 25 ? ChangePositionSize_Z_Score : na, title= "Change Position Size Z-Score", color=color.fuchsia, size = size.large)

labelChange = ""
if (MM_Method == 24 or MM_Method == 25) and ChangePositionSize_Z_Score == true
    labelChange := countWonTrades == MaxPositiveStrips ? "Change_Size: " + str.tostring(EntryCapitalPercentZScorePositiveStrips) + " %" :
         countLostTrades == - MaxNegativeStrips ? "Change_Size: " + str.tostring(EntryCapitalPercentZScoreNegativeStrips) + " %" : na

    label.new(bar_index, na, text=labelChange, yloc=yloc.abovebar, color=color.red)
/////////////////////////////////////////////////////////////// End Change Size Z-Score Labels MM_Method 24/25 ///////////////////////////////////



//////////////////////////////////////////////////////////////////////////// Start Table ////////////////////////////////////////////////////////////////////////////
average_loss = - (strategy.grossloss / strategy.losstrades)
plot(average_loss, title="Average Loss", display=display.data_window)

in_portfolio_risk_percentage = input.float(defval= 2, minval=0, maxval=100, title="Portfolio Risk Percentage", group="Table Inputs", tooltip = "Show The Risk Fraction In The Table")
average_risk_allowed = (strategy.initial_capital * in_portfolio_risk_percentage) / 100

// Max Trade Loss In $
worstMonetaryLoss = 0.0
for i = 0 to strategy.losstrades// number of total trades
    worstMonetaryLoss:= ta.lowest(strategy.closedtrades.profit(i), 1)
plot(worstMonetaryLoss, title="Worst Loss $ Realized", display = display.data_window)


tab1 = table.new(position.top_right, 8, 8, color.white, chart.bg_color, 6, chart.bg_color, 2)
string MMType = MM_Method == 0 ? "FixedContracts"
     : MM_Method == 1 ? "FixedEntryPercentSize"
     : MM_Method == 2 ? "EntryBalancePercent"
     : MM_Method == 3 ? "EntryMonetaryRisk"
     : MM_Method == 4 ? "EntryMonetaryRiskBalancePercent"
     : MM_Method == 5 ? "EntryAtrCapitalRisk"
     : MM_Method == 6 ? "EntryAtrCapitalRiskBalancePercent"
     : MM_Method == 7 ? "EntryAtrCapitalRiskOrig"
     : MM_Method == 8 ? "EntryAtrCapitalRiskBalancePercentOrig"
     : MM_Method == 9 ? "EntryAdxCapitalRisk"
     : MM_Method == 10 ? "EntryAdxCapitalRiskBalancePercent"
     : MM_Method == 11 ? "EntryAdxCapitalRiskOrig"
     : MM_Method == 12 ? "EntryAdxCapitalRiskBalancePercentOrig"
     : MM_Method == 13 ? "EntryCapitalPercentRelativeDDPerc"
     : MM_Method == 14 ? "EntryBalancePercentRelativeDDPerc"
     : MM_Method == 15 ? "EntryCapitalPercentFMaxLoss"
     : MM_Method == 16 ? "EntryBalancePercentFMaxLoss"
     : MM_Method == 17 ? "EntryCapitalPercentFStopLoss"
     : MM_Method == 18 ? "EntryBalancePercentFStopLoss"
     : MM_Method == 19 ? "EntryCapitalPercentFMaxDDMonetaryLoss"
     : MM_Method == 20 ? "EntryBalancelPercentFMaxDDMonetaryLoss"
     : MM_Method == 21 ? "EntryFixedRatio"
     : MM_Method == 22 ? "EntryCapitalPercentWinLossRatio"
     : MM_Method == 23 ? "EntryBalancePercentWinLossRatio"
     : MM_Method == 24 ? "EntryCapitalPercentZ_Score"
     : MM_Method == 25 ? "EntryBalancePercentZ_Score"  : na

table.cell(tab1, 0, 0, 'Money Management Type: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 1, 0, MMType , text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 0, 1, 'Initial Capital: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 1, 1, str.tostring(strategy.initial_capital ), text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 0, 2, 'Portfolio Risk Percentage: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 1, 2, str.tostring(in_portfolio_risk_percentage), text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 0, 3, 'Average Loss Allowed: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 1, 3, str.tostring(- average_risk_allowed), text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 0, 4, 'Average Loss Realized: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 1, 4, str.tostring(average_loss), text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 0, 5, 'Worst Loss Realized: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab1, 1, 5, str.tostring(worstMonetaryLoss), text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))


tab2 = table.new(position.top_center, 8, 8, color.white, chart.bg_color, 6, chart.bg_color, 2)
string MMType2 = MM_Method == 0 ? "FixedContracts"
     : MM_Method == 1 ? "EntryCapitalPercent"
     : MM_Method == 2 ? "EntryBalancePercent"
     : MM_Method == 3 ? "EntryCapitalPercent/Stop Loss Percent MM_Method"
     : MM_Method == 4 ? "EntryCapitalPercent/Stop Loss Percent MM_Method"
     : MM_Method == 5 ? "EntryCapitalPercent/Period_ATR/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 6 ? "EntryCapitalPercent/Period_ATR/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 7 ? "EntryCapitalPercent/Period_ATR/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 8 ? "EntryCapitalPercent/Period_ATR/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 9 ? "EntryCapitalPercent/DI Length/ADX Smoothing/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 10 ? "EntryCapitalPercent/DI Length/ADX Smoothing/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 11 ? "EntryCapitalPercent/DI Length/ADX Smoothing/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 12 ? "EntryCapitalPercent/DI Length/ADX Smoothing/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 13 ? "EntryCapitalPercent/Start End Strip/Size Strip"
     : MM_Method == 14 ? "EntryCapitalPercent/Start End Strip/Size Strip"
     : MM_Method == 15 ? "EntryCapitalPercent/Worst Loss Realized"
     : MM_Method == 16 ? "EntryCapitalPercent/Worst Loss Realized"
     : MM_Method == 17 ? "EntryCapitalPercent/Monetary_Risk/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 18 ? "EntryCapitalPercent/Monetary_Risk/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 19 ? "EntryCapitalPercent/Max DD Monetary Loss/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 20 ? "EntryCapitalPercent/Max DD Monetary Loss/OnOffContractBalancePerc/MaxcontractBalancePerc"
     : MM_Method == 21 ? "FixedContracts/Ratio/Fixed Ratio Contract Decimals/Truncate"
     : MM_Method == 22 ? "EntryCapitalPercent/Start After Closed Trades/Win Loss Percentage Sup_Inf/Size Win Loss Percentage =Sup_=Inf"
     : MM_Method == 23 ? "EntryCapitalPercent/Start After Closed Trades/Win Loss Percentage Sup_Inf/Size Win Loss Percentage =Sup_=Inf"
     : MM_Method == 24 ? "Entry Capital Percent Z Score/Entry Capital Percent Z Score Positive_Negative Strips/Max Positive_Negative Strips"
     : MM_Method == 25 ? "Entry Capital Percent Z Score/Entry Capital Percent Z Score Positive_Negative Strips/Max Positive_Negative Strips"  : na

table.cell(tab2, 0, 0, 'Inputs: ', text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
table.cell(tab2, 1, 0, MMType2 , text_halign=text.align_left, text_size=size.normal, text_color=#424242, bgcolor=color.new(#84e59e, 20))
//////////////////////////////////////////////////////////////////////////// End Table ////////////////////////////////////////////////////////////////////////////


//////////////////////////////////////////////////////////////////////////// End Money Management ////////////////////////////////////////////////////////////////////////////

// {

                                                                    // Spiegazione Money Management //

////////////////////////////////////////////////// 1) MM_Method == 0 / Contratti Fissi (Puro) ///////////////////////////////////////////////////////////

// Compro sempre lo stesso numero di pezzi senza fare caso del valore del sottosatante che cambia nel tempo.
// ES: entrata 1 pezzo uguale al sottostante: 457,23 / pezzi = (1) / stop 20% = 91,446 $
// ES: entrata 1 pezzo uguale al sottostante: 2000 / pezzi = (1) / stop 20% = 400 $
// lo stop monetario è maggiore perchè il sottostante quota di più e pagandolo di più entro con più size perdendo di più, vale anche la prova contraria quando vale meno.

// Possiamo dire che entrando sempre con la stessa size e avendo uno stop in % sempre uguale, lo stop in $ cambia ed il tk in $ cambia a seconda di quanto è quotato il sottostante.
// Se io nella 1ma operazione prendo uno stop di 91,446 $ e nella 2nda operazione potrei prendere uno stop di 400 $ anche se lo stop in % è uguale
// Anche se ho uno stop dinamico tipo media il discorso è sempre uguale, cambia solo che la % di stop che cambia avendo una media o indicatore quindi condizioni di uscite dettate dalla strategia.
// Entrambi i modi potrebbero influire tanto sull'equity portandomi a DD molto veloci anche in poche operazione non avendo sotto controllo la perdita in $.
// Questo metodo lo vedo meglio sul buy and hold e non sul trading.

////////////////////////////////////////////////// 2) MM_Method == 1 / Monetario Fisso (Ingresso In % Del Capitale Iniziale) ///////////////////////////////////////////////////////////

// Entro sempre con un controvalore monetario definito ES: Il 10% Del Capitale Iniziale acquistando il numero di pezzi variabili che cambiano nel tempo a  seconda della quotazione del sottostante.
// ES: Prendo una frazione del capitale Iniziale con il quale voglio entrare in posizione e userò sempre quella.
// Questo tipo di entrata è più bianciata in quanto se ho uno stop fisso in % perderò sempre la stessa somma di denaro perchè la size di ingresso è sempre uguale adeguandosi alla quotazione del sottosatante.
// Diverso è se non ho uno stop fisso in % perchè la strategia semplicemente esce in stop a seconda delle condizioni di uscita che potrebbero avere uno stop più largo o più stretto delle operazioni precedenti.
// Da notare che la perdita monetaria sarà la percentuale dello stop calcolata sulla size di ingresso quindi se entro con il 2% di 1000$ non perderò 20$ ma perderò la % di stop dei 20$ "sempre se ho uno stop loss fisso" altrimenti lo stop sarà variabile se l'uscita non ha uno stop loss fisso.

////////////////////////////////////////////////// 3) MM_Method == 2 / Ingresso In % Del Balance ///////////////////////////////////////////////////////////

// L'EntryBalancePercent permette di entrare con una % del capitale prestabilita che ovviamente cambierà al cambiare della mia equity.
// Questo tipo di ingresso risulta bilanciato accellerando a rialzo il volume di ingresso quando le cose vanno bene ed al contrario riducendo il volume di ingresso quando le cose vanno male.
// Come pro abbiamo la situazione descritta sopra ma come contro abbiamo che la perdite ricevute dopo un grande periodo run up saranno più consistenti.
// Lo stop monetario cambia sia che usiamo uno stop fisso in % sia che abbiamo altri tipi di stop dettati dalla strategia.

////////////////////////////////////////////////// 4) MM_Method == 3 / Rischio Monetario Fisso (In % Del Capitale Iniziale) ///////////////////////////////////////////////////////////

// Questo metodo permette di entrare con una size impostata sulla perdita stabilita dalla nostra strategia perdendo sempre lo stesso importo monetario per strategie che hanno uno stop prestabilito.
// Per ragioni di comodità il rapporto della perdita è stato impostato in % al capitale iniziale
// ES: voglio perdere il 2% del capitale iniziale : 1000 * 2 /100 = 20$ entrerò in posizione con una size dove andrò a perdere 20$.
// ES: voglio perdere il 4% del capitale iniziale : 1000 * 4 /200 = 40$ entrerò in posizione con una size dove andrò a perdere 40$.
// Per strategie dove lo stop è variabile dettato dalle regole di uscita tipo medie o altro la perdita ricevuta non sarà sempre uguale ma cambierà di trade in trade a seconda delle regole di uscita della strategia.

// ESEMPIO CONCRETO: PERDITA CALCOLATA 20$..... STOP LOSS 14,20% .... (20$ / 14,20%) * 100 = SIZE INGRESSO 140,84$ /  CLOSE(2.175,59) = SIZE IN PEZZI ()
// PEZZI(0,064)

// perdita calcolata = initial capitale * risk percent / 100 = stop loss monetario
// stop loss monetario / stop loss percentuale * 100 = SIZE INGRESSO
// SIZE INGRESSO / close = pezzi da acquistare

////////////////////////////////////////////////// 5) MM_Method == 4 Rischio Monetario Fisso (In % Del Balance) ///////////////////////////////////////////////////////////

// Questo metodo permette di entrare con una size impostata sulla perdita in % al balance stabilita dalla nostra strategia perdendo sempre la stessa % anche se lo stop loss % cambia, l'importo monetario di stop cambia nel tempo al cambiare della nostra equity per strategie che hanno uno stop prestabilito ma rispecchierà sempre la perdita % della nostra equity.
// Questo tipo di approccio favorisce l'ingresso con size maggiori quando le cose vanno bene e al contrario riduce la size quando le cose vanno male.
// Il contro di questo approccio è che dopo un perido di grandi profitti le prime perdite vicine subite dopo il grande guadagno saranno più consistenti.
// Per ragioni di comodità il rapporto della perdita è stato impostato in % al capitale dell'equity che cambia
// ES: voglio perdere il 2% dell'equity : 1000 * 2 /100 = 20$ entrerò in posizione con una size dove andrò a perdere 20$ anche se lo stop loss in % della strategia può essere impostato più o meno ampio.
// ES: voglio perdere il 2% dell'equity : 1050 * 2 /200 = 21$ entrerò in posizione con una size dove andrò a perdere 21$ anche se lo stop loss in % della strategia può essere impostato più o meno ampio.
// Per strategie dove lo stop è variabile dettato dalle regole di uscita tipo medie o altro la perdita ricevuta non potrà rispettare il criterio della perdita in % sull'equity perchè lo stp loss non è fisso ma varia a seconda delle regole di uscita della strategia.

// perdita calcolata = equity * risk percent / 100 = stop loss monetario
// stop loss monetario / stop loss percentuale * 100 = SIZE INGRESSO
// SIZE INGRESSO / close = pezzi da acquistare

////////////////////////////////////////////////// 6) MM_Method == 5 Atr In % Al Rischio Del Capitale Iniziale ///////////////////////////////////////////////////////////

// La formula originale è questa: (InitialCapital * EntryCapitalPercent / 100)  / (ATRValue * close)
// Solo che con la formula originale abbiamo un problema: Quando il capitale è troppo piccolo la size di ingresso è praticamente minima allora ho risolto nel modo che segue controllando che la size non eccede il mio balance usando: OnOffContractBalancePerc E MaxcontractBalancePerc

// ABBIAMO USATO IL METODO 2 IN BASSO: // 2 (RiskFraction % * Capitale) / atr = pezzi     (2 * 1000) / 24 = 83,33 $
// ABBIAMO UN CAPITALE INIZIALE FISSO E IN BASE AL NOSTRO RISCHIO ES IL 2% DEL CAPITALE E ANCHE IN BASE ALL'ATR SI ENTRA IN POSIZIONE.
// QUESTO TIPO DI ENTRATA PERMETTERA' UNA SIZE MAGGIORE QUANDO L'ATR E MINORE E VICE VERSA.
// DOVREBBE SMUSSARE L'EQUITY DATO CHE QUANDO IL RISCHIO SI ALZA ENTRIAMO CON MENO CAPITALE
// RIGUARDA SOLO L'ENTRATA E NON LA DIMENSIONE DELLA PERDITA O STOP LOSS, LA PERDITA CHE CAMBIARA' IN BASE ALLA DIMENSIONE DEL NOSTRO STOP O USCITA STRATEGIA MEDIE ETC... ED AL TIPO DI SIZE CHE HA CALCOLATO



// 1 RiskFraction / atr = pezzi
// 2 (RiskFraction % * Capitale / atr) / close = pezzi     (2 * 1000) / 24"ATR" = 83,33 $    DA DIVIDERE PER LA CLOSE !!!
// 3 (RiskFraction $ * Capitale / atr) / close = pezzi     (20 * 1000) / 24"ATR" = 833,33 $  DA DIVIDERE PER LA CLOSE !!!
// a = 100 / (ATRValue * close)
// plot(a, title="a")


// 2 size = 2 * 1000 / ATRValue
// plot(size, title="size")

////////////////////////////////////////////////// 7) MM_Method == 6 Atr In % Al Rischio Del Balance ///////////////////////////////////////////////////////////

// La formula originale è questa: (Balance * EntryCapitalPercent / 100)  / (ATRValue * close)
// Solo che con la formula originale abbiamo un problema: Quando il capitale è troppo piccolo la size di ingresso è praticamente minima allora ho risolto nel modo che segue controllando che la size non eccede il mio balance usando: OnOffContractBalancePerc E MaxcontractBalancePerc

// ABBIAMO USATO IL METODO 2 IN BASSO: // 2 (RiskFraction % * Capitale) / atr = pezzi     (2 * 1000) / 24 = 83,33 $
// ABBIAMO UN CAPITALE CHE SI MUOVE "BALANCE" E IN BASE AL NOSTRO RISCHIO ES IL 2% DEL BALANCE E ANCHE IN BASE ALL'ATR SI ENTRA IN POSIZIONE.
// QUESTO TIPO DI ENTRATA PERMETTERA' UNA SIZE MAGGIORE QUANDO L'ATR E MINORE E VICE VERSA ED E' DA PIU' O MENO PESO ALLA SIZE DI INGRESSO A SECONDA SE IL BALANCE SALE O SCENDE.
// DOVREBBE SMUSSARE L'EQUITY DATO CHE QUANDO IL RISCHIO SI ALZA ENTRIAMO CON MENO CAPITALE E ANCHE AL FATTO CHE USIAMO IL BALANCE.
// RIGUARDA SOLO L'ENTRATA E NON LA DIMENSIONE DELLA PERDITA O STOP LOSS, LA PERDITA CHE CAMBIARA' IN BASE ALLA DIMENSIONE DEL NOSTRO STOP O USCITA STRATEGIA MEDIE ETC... ED AL TIPO DI SIZE CHE HA CALCOLATO



// 1 RiskFraction / atr = pezzi
// 2 (RiskFraction % * Capitale / atr) / close = pezzi     (2 * 1000) / 24"ATR" = 83,33 $    DA DIVIDERE PER LA CLOSE !!!
// 3 (RiskFraction $ * Capitale / atr) / close = pezzi     (20 * 1000) / 24"ATR" = 833,33 $  DA DIVIDERE PER LA CLOSE !!!
// a = 100 / (ATRValue * close)
// plot(a, title="a")


// 2 size = 2 * 1000 / ATRValue
// plot(size, title="size")

////////////////////////////////////////////////// 8) MM_Method == 7 Atr In % Al Rischio Del Capitale Iniziale Orig ///////////////////////////////////////////////////////////

// Questo metodo è simile al: MM_Method == 5 Atr In % Al Rischio Del Capitale Iniziale ma usa la formula originale dove la percentuale di capitale che vogliamo rischiare in ingresso in posizione è divisa per l'atr e
// poi ovviamente ancora divisa per la close per ottenere il numero di pezzi da acquistare.

////////////////////////////////////////////////// 9) MM_Method == 8 Atr In % Al Rischio Del Balance Orig ///////////////////////////////////////////////////////////

// Questo metodo è simile al: MM_Method == 6 Atr In % Al Rischio Del Balance ma usa la formula originale dove la percentuale di capitale che vogliamo rischiare in ingresso in posizione è divisa per l'atr e
// poi ovviamente ancora divisa per la close per ottenere il numero di pezzi da acquistare.

////////////////////////////////////////////////// 10) MM_Method == 9 Adx In % Al Rischio Del Capitale Iniziale //////////////////////////////////////////////////

// La formula originale è questa: (InitialCapital * EntryCapitalPercent / 100)  / (adx * close)
// Solo che con la formula originale abbiamo un problema: Quando il capitale è troppo piccolo la size di ingresso è praticamente minima allora ho risolto nel modo che segue controllando che la size non eccede il mio balance usando: OnOffContractBalancePerc E MaxcontractBalancePerc

// E' come l'atr solo che usa adx, questo è impostato sul capitale iniziale.

////////////////////////////////////////////////// 11) MM_Method == 10 Adx In % Al Rischio Del Balance //////////////////////////////////////////////////

// La formula originale è questa: (Balance * EntryCapitalPercent / 100)  / (adx * close)
// Solo che con la formula originale abbiamo un problema: Quando il capitale è troppo piccolo la size di ingresso è praticamente minima allora ho risolto nel modo che segue controllando che la size non eccede il mio balance usando: OnOffContractBalancePerc E MaxcontractBalancePerc

// E' come l'atr solo che usa adx, questo è impostato sul balance.

////////////////////////////////////////////////// 12) MM_Method == 11 Adx In % Al Rischio Del Capitale Iniziale Orig //////////////////////////////////////////////////

// Questo metodo è simile al: MM_Method == 9 Adx In % Al Rischio Del Capitale Iniziale ma usa la formula originale dove la percentuale di capitale che vogliamo rischiare in ingresso in posizione è divisa per l'adx e
// poi ovviamente ancora divisa per la close per ottenere il numero di pezzi da acquistare.

////////////////////////////////////////////////// 13) MM_Method == 12 Adx In % Al Rischio Del Balance Orig //////////////////////////////////////////////////

// Questo metodo è simile al: MM_Method == 10 Adx In % Al Rischio Del Balance ma usa la formula originale dove la percentuale di capitale che vogliamo rischiare in ingresso in posizione è divisa per l'adx e
// poi ovviamente ancora divisa per la close per ottenere il numero di pezzi da acquistare.

////////////////////////////////////////////////// 14) MM_Method == 13 Monetario In Percentuale Al Capitale Iniziale Diviso In Fasce Su EntryCapitalPercent In Base Alle Fasce Max DD % //////////////////////////////////////////////////

// Queste tecnica usa la % del capitale iniziale, entra a fasce sempre minori di size se il relative drawdown % aumenta, le fasce sono state fatte sul EntryCapitalPercent
// si ritorna pian piano alla size originale se il relativo drawdown % diminuisce o si azzera.
                                                            // Modo di utilizzo //
// Con l'input Max MaxDrawdownPercentCalculator andiamo a calcolare la percentuale di Drawdown che desideriamo e sul plot otteniamo i valori che andremo ad inserire nella costruzione delle fasce.
// Attenzione prima di usare il MaxDrawdownPercentCalculator tutte le size "sia Entry Capital Percent che tutte le size quelle delle fasce" devono essere uguali prima del calcolo, altrimenti cambierà il Max Drawdown !!!

// Creazione delle fasce ES: del 90%, 80%, 70% sul massimo drawdown
// Una volta create le fasce sul massimo drawdown la size di ingresso in posizione sarà sempre a fasce ES: del 90%, 80%, 70% ma dell'EntryCapitalPercent
// ES: Capitale Iniziale = 1500, ingresso deciso con il 25% del Capitale Iniziale. 1500 * 25 / 100 = 250$ da convertire in pezzi ...
// prendo i 250$ e creo delle fasce del 90%, 80%, 70% sui 250$
// se il relative drawdown aumenta ed è nella 1ma fascia allora farò: 250$ * il 90% del 25% "che era la percententuale di size stabilita all'inizio" e mi ricava i pezzi...
// continuo con questo metodo anche con le altre fasce.

////////////////////////////////////////////////// 15) MM_Method == 14 Monetario In Percentuale Al Balance Diviso In Fasce Su EntryCapitalPercent In Base Alle Fasce Max DD % //////////////////////////////////////////////////

// Queste tecnica usa la % del balance, entra a fasce sempre minori di size se il relative drawdown % aumenta, le fasce sono state fatte sul EntryCapitalPercent
// si ritorna pian piano alla size originale se il relativo drawdown % diminuisce o si azzera.
                                                            // Modo di utilizzo //
// Con l'input Max MaxDrawdownPercentCalculator andiamo a calcolare la percentuale di Drawdown che desideriamo e sul plot otteniamo i valori che andremo ad inserire nella costruzione delle fasce.
// Attenzione prima di usare il MaxDrawdownPercentCalculator tutte le size "sia Entry Capital Percent che tutte le size quelle delle fasce" devono essere uguali prima del calcolo, altrimenti cambierà il Max Drawdown !!!

// Creazione delle fasce ES: del 90%, 80%, 70% sul massimo drawdown
// Una volta create le fasce sul massimo drawdown la size di ingresso in posizione sarà sempre a fasce ES: del 90%, 80%, 70% ma dell'EntryCapitalPercent
// ES: Balance = 1500, ingresso deciso con il 25% del balance. 1500 * 25 / 100 = 250$ da convertire in pezzi ...
// prendo i 250$ e creo delle fasce del 90%, 80%, 70% sui 250$
// se il relative drawdown aumenta ed è nella 1ma fascia allora farò: 250$ * il 90% del 25% "che era la percententuale di size stabilita all'inizio" e mi ricavo i pezzi...
// continuo con questo metodo anche con le altre fasce.

////////////////////////////////////////////////// 16) MM_Method == 15 Monetario Fisso In Percentuale Al Capitale Iniziale Proporzionato Alla Massima Perdita Monetaria " Percent F Capitale Iniziale Max Loss " //////////////////////////////////////////////////

// E' il Percent F Capitale Iniziale Max Loss.

// Prendo il capitale iniziale, ne traggo una pecentuale di rischio e la adatto alla massima perdita monetaria realizzata dell'intera strategia caricata precedentemente ad 1 contratto fisso.
// In questo modo la massima pedita realizzata della strategia sarà sempre uguale alla mia percentuale di rischio scelta.

                                    // UTILIZZO PRATICO //
// Impostare MM_Method Ingresso Contratti Fissi con 1 contratto e vedere la massima perdita dell'intera strategia in termini monetari.
// Impostare MM_Method EntryCapitalPercentFMaxLoss, Entry Capital Percent e Worst Loss Realized con la perdita massima monetaria derivata da 1 contratto fisso.
// Il worst case scenario, può essere utilizzato su vari parametri: Peggior Perdita Storica, Stop Loss Della Strategia, Media Degli Ultimi "n" Peggior Trade, Worst Time Performance "Weelly, Daily, etc..", Max Drawdown Storico % o Monatario

// Pro: E' molto utile per uniformare solamente strategie di natura simile avendo un rischio della massima perdita controllata.
// Contro: Solitamente entra con troppo poco capitale.
// Contro: Se ho delle perdite molto grandi ma rarissime, rischio di entrare sempre nella strategia con una size troppio piccola.
// Contro: Non posso uniformare tutte le strategie, specialmente se alcune strategie rimangono in trade molto tempo e altre pochissimo tempo.
// Contro: Non posso uniformare tutte le strategie, strategie con stop grandi saranno sottodimensionate, vale l'opposto con stop troppo piccoli.

////////////////////////////////////////////////// 17) MM_Method == 16 Monetario Fisso In Percentuale Al Balance Proporzionato Alla Massima Perdita Monetaria " Percent F Balance Max Loss " //////////////////////////////////////////////////

// E' simile al " Percent F Initial Capital Max Loss " solo che fa riferimento al Balance e non al Capitale Iniziale.
// Da notare che il report finale cambia: Profitto, Max loss In $, Max Drawdown etc... Cambiano anche se imposto la frazione del capitale rischiata al 2% come per il capitale iniziale.
// Da notare che anche se aggiusto la frazione del capitale rischiata all'equivalente della massima perdita come per il capitale iniziale le metriche rimangono comunque diverse.

////////////////////////////////////////////////// 18) MM_Method == 17 Monetario Fisso In Percentuale Al Capitale Iniziale Proporzionato Allo Stop Loss Monetario " Percent F Capitale Iniziale Stop Loss Monetario " //////////////////////////////////////////////////

// E' simile al Percent F Capitale Iniziale Max Loss solo che invece delle Massima Pedita si basa sullo Stop Loss Monetario.
// A differenza del Percent F Capitale Iniziale Max Loss è più aggressivo.
// Impostare la size minima e massima in percentuale al capitale per non eccedere con la size oltre al capitale a disposizione: OnOffContractBalancePerc E MaxcontractBalancePerc.
// Se non abbiamo strategie con una perdita monetaria, potremmo usare la perdita media monetaria della strategia come valore di Imput di Monetary_Risk

////////////////////////////////////////////////// 19) MM_Method == 18 Monetario Fisso In Percentuale Al Balance Proporzionato Allo Stop Loss Monetario " Percent F Balance Stop Loss Monetario " //////////////////////////////////////////////////

// E' uguale al Percent F Capitale Iniziale Stop Loss Monetario solo che usa il Balance invece del capitale iniziale.

////////////////////////////////////////////////// 20) MM_Method == 19 Monetario Fisso In Percentuale Al Capitale Iniziale Proporzionato Al Massimo DD Monetario " Percent F Capitale Iniziale Max DD Monetario " //////////////////////////////////////////////////

// E' simile al Percent F Capitale Iniziale Stop Loss Monetario " solo che fa riferimento al Al Massimo DD Monetario ".
// E' una money management molto cauto forse anche troppo. Il massimo drawdown monetario di tutta la strategia sarà uguale alla percentuale di rischio "in termini monetari" del capitale che abbiamo scelto noi.
// L'input: Max DD Monetary Loss viene preso dai valori con un money management semplice con ingresso a 1 contratto e poi gli stessi valori inseriti nell'input di questo money management.

////////////////////////////////////////////////// 21) MM_Method == 20 Monetario Fisso In Percentuale Al Balance Proporzionato Al Massimo DD Monetario " Percent F Balance Max DD Monetario " //////////////////////////////////////////////////

// E' uguale al Percent F Capitale Iniziale Proporzionato Al Massimo DD Monetario solo che usa il Balance invece del capitale iniziale.
// Il massimo drawdown monetario di tutta la strategia questa volta usando il Balance non sarà uguale alla percentuale di rischio "in termini monetari" del capitale che abbiamo scelto noi.
// L'input: Max DD Monetary Loss viene preso dai valori con un money management semplice con ingresso a 1 contratto e poi gli stessi valori inseriti nell'input di questo money management.

////////////////////////////////////////////////// 22) MM_Method == 21 Monetario Fisso A Step Decisi Dal Delta Sul Sul Balance Raggiunto "Entry Fixed Ratio" //////////////////////////////////////////////////

// Il Fixed Ratio prevede di partire con una size fissa che viene decisa a priori e solo quando viene raggiunto una somma monetaria "delta, o ratio" decisa sempre a priori
// si aumenta o diminuisce la size solo quando ogni contratto in uso ha portato un certo di livello di profitto ossia il "Delta".
// La size che aumenta o diminuisce è stata decisa dal delta per ogni singola size, ovvero per ogni size decisa inizialente ci sarà un delta che verrà aggiunto o diminuito.

// ES: Capitale = 1.000, Contratto Iniziale = 1, Delta = 250. Contratto di partenza = 1
// 1mo Aumento di un'altro contratto solo quando il mio capitale sarà = 1.000 + (1 * 250 "250") Tot 1.250      (Contratti Tot 2)
// 2ndo Aumento di un'altro contratto solo quando il mio capitale sarà = 1.250 + (2 * 250 "500") Tot 1.750     (Contratti Tot 3)
// 3rzo Aumento di un'altro contratto solo quando il mio capitale sarà = 1.750 + (3 * 250 "750") Tot 2.500     (Contratti Tot 4)
// 4rto Aumento di un'altro contratto solo quando il mio capitale sarà = 2.500 + (4 * 250 "1.000") Tot 3.500   (Contratti Tot 5)
// 4nto Aumento di un'altro contratto solo quando il mio capitale sarà = 3.500 + (5 * 250 "1.250") Tot 4.750   (Contratti Tot 5)

// Questo si applica sia per incrementare sia per scalare di posizione.
// Questo approccio mostra una partenza più o meno forte "a seconda della size di ingressio iniziale" ma che si attenua nel col corso della strategia dato dal delta.
// Più il delta è basso, maggiore sarà la rischiosità della strategia.

////////////////////////////////////////////////// 23) MM_Method == 22 Monetario In Percentuale Al Capitale Iniziale Win/Loss Ratio //////////////////////////////////////////////////

// Prima di iniziare, impostare tutte le size di ingresso di questo MM_Method con la stessa percentuale per studiare meglio la strategia senza modificare la size di ingresso e poi iniziare ad applicare
// questa tecnica prima ad un'estremo: "Size Win Loss Percentage =Sup" e dopo aver riportato la size nuovamente a quella originale provare con l'altro estremo: "Size Win Loss Percentage =Inf" per poi infine provarli entrambi insieme.

// Questa tecnica prevede di aumentare o diminuire la size di ingresso quando la % di Win/Loss si trova agli estremi positivi o negativi oppure entrambi per sfruttare i momenti di forza/debolezza della strategia
// in termini di vincite/perdite dei trades.

// Finchè non vengono superati i trades impostati da input: Start After Closed Trades, la strategia entra con un % del capitale iniziale impostata da Entry Capital Percent.
// Quando l'input Win Loss Percentage Sup/Inf non viene raggiunto o superato, l'ingresso è in % del capitale iniziale impostata da Entry Capital Percent.

// Quando l'input Win Loss Percentage Sup/Inf vengono raggiunti o superati possiamo modificare la size di ingresso con l'inputs: Size Win Loss Percentage =Sup/=Inf.
// Possiamo modificare la size sia quando entrambi gli estremi sono raggiunti o superati oppure usare un solo estremo Sup o Inf e impostare tutto il resto della size uguale a Entry Capital Percent
// in modo da modificare la size di ingresso solo al verificarsi di una sola condizione anzichè di tutte e due le condizioni.

// La prima tecnica potrebbe essere quella di diminuire la size di ingresso quando il win loss ratio è basso e viceversa.
// Un'altra tecnica interessante potrebbe essere quella di diminuire la size di ingresso anzichè aumentarla quando il win loss ratio è alto e viceversa.

// Questo metodo potrebbe avere più senso con strategie dove il win loss ratio ha un'ampio range e potrebbe avere meno senso dove il range è poco
// ad esempio le strategie di forte tendenza potrebbero avere una rara ma grossa vincita e proprio in quel momento abbiamo modificato la size di ingresso.

// Altre simulazioni che si possono fare sono quelle di simulare uno stop della strategia entrando con un capitale redicolo come se la strategia non fosse entrata quando il win loss ratio è agli estremi.

////////////////////////////////////////////////// 24) MM_Method == 23 Monetario In Percentuale Al Balance Win/Loss Ratio //////////////////////////////////////////////////

// E' simile al MM_Method == 22 Monetario In Percentuale Al Capitale Iniziale Win/Loss Ratio solo che usa il Balance e non il Capitale Iniziale.

////////////////////////////////////////////////// 25) MM_Method == 24 Monetario In Percentuale Al Capitale Iniziale Win/Loss Z-Score //////////////////////////////////////////////////

// Questo metodo permette di ottenere le strisce di vincite o perdite consecutive sia in tabella sia sui log e ridurre/aumentare/stoppare la size dei trade in base alla ciclicità delle strisce.

// Verifica: Dopo aver caricato la strategia con un ingresso fisso del capitale iniziale, "per avere un riscontro sempre stabile dell'equity nel tempo", e lo z-score della strategia è +2 o -2 "ciclicità statistica".

                                                    // Metodo (Riduzione Size/Stop Trade) Strisce Vincenti
// Possimo verificare se il massimo delle strisce di trade vinti si ripete più volte nella serie per decidere al prossimo trade di modificare la size riducendola o non effettuare l'ingresso.

                                                    // Metodo (Riduzione Size/Stop Trade) Strisce Perdenti
// Per quanto riguarda il massimo delle strisce di trade persi dovremmo ridurre o saltare il trade un trade prima rispetto alle strisce dei trade vincenti dato che il prossimo trade sarà vincente.

// ES Strisce Vincenti: +1, +2, +3, +1, +3, +4, +3, +3, +5, +3     "Il +3 si ripete spesso"  "Dopo aver incassato la vincita, al 4rto riduco la size o salto il trade".
// ES Strisce Perdenti: -1, -2, -3, -1, -3, -4, -3, -3, -5, -3     "Il -3 si ripete spesso"  "Prima di aver incassato la perdita, al 2condo riduco la size o salto il trade per non incassare la 3rza perdita".

                                                    // Metodo (Aumento Size) Strisce Vincenti

// Possimo verificare se il massimo delle strisce di trade vinti si ripete più volte nella serie per decidere al trade prima del massimo della striscia di modificare la size aumentandola.

                                                    // Metodo (Aumento Size) Strisce Perdenti

// Possimo verificare se il massimo delle strisce di trade persi si ripete più volte nella serie per decidere al trade successivo del massimo della striscia modificare la size aumentandola.

// ES Strisce Vincenti: +1, +2, +3, +1, +3, +4, +3, +3, +5, +3     "Il +3 si ripete spesso"  "Dopo aver incassato la vincita del 2ndo trade "trade prima del massimo della striscia", aumento la size per il 3rzo trade".
// ES Strisce Perdenti: -1, -2, -3, -1, -3, -4, -3, -3, -5, -3     "Il -3 si ripete spesso"  "Dopo aver incassato la perdita al 3rzo trade,  aumento la size per il 4rto trade".

////////////////////////////////////////////////// 26) MM_Method == 25 Monetario In Percentuale Al Balance Win/Loss Z-Score //////////////////////////////////////////////////

// E' simile al MM_Method == 24 Monetario In Percentuale Al Capitale Iniziale Win/Loss Z-Score solo che usa il balance.

//}

MM_Strategy_Separator = input.string(defval = "",title= "//////////////// START STRATEGY ////////////////")

//////////////////////////////////////////////////////////////////////// INIZIO STRATEGIA ////////////////////////////////////////////////////////////////////////


// Input
input_ema = input.int(title='Media Ema', defval=90, minval=0, maxval=500)
input_apertura_minima = input.float(title='perc_apertura_minima', defval=2, group='Filtri Posizione')
input_apertura_massima = input.float(title='perc_apertura_massima', defval=4, group='Filtri Posizione ')
input_chiusura_minima = input.float(title='perc_chiusura_minima', defval=0, group='Filtri Posizione')
input_trailing_stop_trigger = input.float(title='input_trailing_stop_trigger', defval=12, group='trailing ')
input_trailing_stop_close = input.float(title='input_trailing_stop_close', defval=6, group='trailing ')
onlyLong = input.bool(title='Solo long', defval=false, inline='1', group='Direzione')
onlyShort = input.bool(title='Solo short', defval=false, inline='1', group='Direzione')
input_stop_loss_long = input.float(title='stop_loss_long', defval=10, minval=0, maxval=100, step=0.1, group='Stop Loss')
input_stop_loss_short= input.float(title='stop_loss_short', defval=10, minval=0, maxval=100, step=0.1, group='Stop Loss')
input_risk = input.float(title='Risk Per Trade %', defval=25.2, minval=0, maxval=100, step=0.01, group='Risk Per Trade %')


// Calcolo del range del backtest
startDate = input.int(title="Start Date",
     defval=17, minval=1, maxval=31, group="Periodo")
startMonth = input.int(title="Start Month",
     defval=08, minval=1, maxval=12, group="Periodo")
startYear = input.int(title="Start Year",
     defval=2000, minval=1800, maxval=2100, group="Periodo")

endDate = input.int(title="End Date",
     defval=01, minval=1, maxval=31, group="Periodo")
endMonth = input.int(title="End Month",
     defval=01, minval=1, maxval=12, group="Periodo")
endYear = input.int(title="End Year",
     defval=2121, minval=1800, maxval=2150, group="Periodo")


inDateRange = (time >= timestamp(syminfo.timezone, startYear,
         startMonth, startDate, 0, 0)) and
     (time < timestamp(syminfo.timezone, endYear, endMonth, endDate, 0, 0))


//Calcolo degli indicatori

// Variabili Medie Ema
ema = ta.ema(close, input_ema)
ema1 = ta.ema(close[1], input_ema)
plot(ema, color=color.new(color.green, 0), title='Media_Ema', linewidth=2)


//Calcolo filtri apertura minima
apertura_minima = ema / 100 * input_apertura_minima
apertura_minima1 = ema1 / 100 * input_apertura_minima
apertura_massima = ema / 100 * input_apertura_massima
chiusura_minima = ema / 100 * input_chiusura_minima


// Filtri Bande Long
filtro_long_basso = ema + apertura_minima
filtro_long_alto = ema + apertura_massima


plot_filtro_long_basso = plot(filtro_long_basso, color=color.new(color.blue, 0), title='filtro_long_basso')
plot_filtro_long_alto = plot(filtro_long_alto, color=color.new(color.blue, 0), title='filtro_long_alto')
fill(plot_filtro_long_basso, plot_filtro_long_alto, title='Spazio di apertura', color=color.new(color.blue, 90))


// Filtri Bande Short
filtro_short_basso = ema - apertura_minima
filtro_short_alto = ema - apertura_massima


plot_filtro_short_basso = plot(filtro_short_basso, color=color.new(color.red, 0), title='filtro_short_basso')
plot_filtro_short_alto = plot(filtro_short_alto, color=color.new(color.red, 0), title='filtro_short_alto')
fill(plot_filtro_short_basso, plot_filtro_short_alto, title='Spazio di apertura', color=color.new(color.red, 90))


// Stop Loss Long E Short
stop_loss_long_price = strategy.opentrades.entry_price(0) - (strategy.opentrades.entry_price(0) * input_stop_loss_long) / 100
stop_loss_long = (strategy.opentrades.entry_price(0) - stop_loss_long_price) / syminfo.mintick


stop_loss_short_price = strategy.opentrades.entry_price(0) + (strategy.opentrades.entry_price(0) * input_stop_loss_short) / 100
stop_loss_short = (stop_loss_short_price - strategy.opentrades.entry_price(0)) / syminfo.mintick


// Trailing Stop Long E Short
trailing_stop_trigger_long = strategy.opentrades.entry_price(0) + (strategy.opentrades.entry_price(0) * input_trailing_stop_trigger)/100
trailing_stop_close_long = strategy.opentrades.entry_price(0) + (strategy.opentrades.entry_price(0) * input_trailing_stop_close)/100
trailing_stop_trigger_short = strategy.opentrades.entry_price(0) - (strategy.opentrades.entry_price(0) * input_trailing_stop_trigger)/100
trailing_stop_close_short = strategy.opentrades.entry_price(0) - (strategy.opentrades.entry_price(0) * input_trailing_stop_close)/100


// Plot Ingresso In Posizione
plot(strategy.position_size != 0 ? strategy.opentrades.entry_price(0) : na , color=strategy.position_size > 0 ? color.blue : strategy.position_size < 0 ? color.red : na, style=plot.style_linebr, title="entry_price") // stampa l'entry price in rosso se short in blu se long
plot(strategy.position_size > 0 ?  trailing_stop_trigger_long : strategy.position_size < 0 ? trailing_stop_trigger_short: na, color=color.blue, style=plot.style_cross, linewidth=2, title="trail_trigger")
plot(strategy.position_size > 0 ?  trailing_stop_close_long : strategy.position_size < 0 ? trailing_stop_close_short: na, color=color.blue, style=plot.style_cross, linewidth=2, title="trail_close")
plot(strategy.position_size > 0 ?  stop_loss_long_price : strategy.position_size < 0 ? stop_loss_short_price: na, color=color.red, style=plot.style_cross, linewidth=2, title="sl_limit")

bgcolor(strategy.position_size > 0 ? color.green : strategy.position_size < 0 ? color.red : na, transp=90) // sfondo verde quando siamo long, sfondo rosso quando siamo short, no sfondo quando non siamo in posizione


range_barre_trailing = bar_index - strategy.opentrades.entry_bar_index(0) +1
//plot(lunghezza_trailing, title = 'lunghezza')

highesthigh = strategy.opentrades ==1 ? ta.highest(high, range_barre_trailing): na
//plot(highesthigh)

lowestlow = strategy.opentrades ==1 ? ta.lowest(low, range_barre_trailing): na
//plot(lowestlow)



//Condizione Entrata Long: Chiusura candela sopra media lenta con differenziale medie e media veloce maggiore media ExitLong
condEntryLong = close > ema + apertura_minima and close < ema + apertura_massima and close > open  and not onlyShort and inDateRange and (close[1] < ema1 + apertura_minima or low[1] < ema1 + apertura_minima) // and adx_long > differenziale_adx_long// and dayofweek != 7 and month !=10

//Condizione Uscita Long: Crossunder di due medie
condExitLong = close < ema - chiusura_minima

// Condizione Uscita Trailing Stop Long
condExitLong2 =  (highesthigh >= trailing_stop_trigger_long and close <= trailing_stop_close_long)

//Condizione Entrata Short: Crossunder di due medie con il prezzo di chiusura che è comunque sotto una terza media con differenziale delle medie
condEntryShort = close < ema - apertura_minima and close > ema - apertura_massima and close < open  and not onlyLong and inDateRange and (close[1] > ema1 - apertura_minima or high[1] > ema1 - apertura_minima) // and adx_short > differenziale_adx_short // and dayofweek != 7 and month !=10

//Condizione Uscita Short: Crossover di medie con il prezzo di chiusura che è comunque sopra una terza media
condExitShort = close > ema + chiusura_minima

// Condizione Uscita Trailing Stop Short
condExitShort2 = (lowestlow <= trailing_stop_trigger_short and close >= trailing_stop_close_short)

barcolor(condEntryLong ? color.lime : condEntryShort ? color.purple : na)


// Alerts
buy_command = 'buy_command'
sell_command = 'sell_command'
close_command = 'close_command'


//entrata e uscita Long
if condEntryLong
    strategy.entry('long', strategy.long, alert_message = "Open Long Position", comment = buy_command, qty=posSize)
    strategy.exit('stop loss long', from_entry='long', loss=stop_loss_long, alert_message = "Your Long SL Has Been Triggered.", comment = close_command)

if condExitLong
    strategy.close(id='long', alert_message = "Close Long Position", comment = close_command)

if strategy.opentrades ==1 and condExitLong2
    strategy.close(id='long', alert_message = "Trailing long", comment = close_command)

//entrata e uscita Short
if condEntryShort
    strategy.entry('short', strategy.short, alert_message = "Open Short Position", comment = sell_command, qty=posSize)
    strategy.exit('stop loss short', from_entry='short', loss=stop_loss_short, alert_message = "Your Short SL Has Been Triggered.", comment = close_command)

if condExitShort
    strategy.close(id='short', alert_message = "Close Short Position", comment = close_command)

if strategy.opentrades ==1 and condExitShort2
    strategy.close(id='short', alert_message = "Trailing Short", comment = close_command)


//////////////////////////////////////////////////////////////////////// FINE STRATEGIA ////////////////////////////////////////////////////////////////////////