package com.qianwen.core.tenant;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ExceptionUtils;
import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
import net.sf.jsqlparser.expression.BinaryExpression;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.Parenthesis;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.MultiExpressionList;
import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.delete.Delete;
import net.sf.jsqlparser.statement.insert.Insert;
import net.sf.jsqlparser.statement.select.FromItem;
import net.sf.jsqlparser.statement.select.Join;
import net.sf.jsqlparser.statement.select.ParenthesisFromItem;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
import net.sf.jsqlparser.statement.select.SelectItem;
import net.sf.jsqlparser.statement.select.SubJoin;
import net.sf.jsqlparser.statement.update.Update;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.CollectionUtil;
import net.sf.jsqlparser.expression.operators.relational.ItemsList;

public class BladeTenantInterceptor extends TenantLineInnerInterceptor {
    private TenantLineHandler tenantLineHandler;
    private BladeTenantProperties tenantProperties;
    private List<String> adminTenantTables = Arrays.asList("blade_top_menu", "blade_dict_biz");

    public void setTenantProperties(final BladeTenantProperties tenantProperties) {
        this.tenantProperties = tenantProperties;
    }

    public void setAdminTenantTables(final List<String> adminTenantTables) {
        this.adminTenantTables = adminTenantTables;
    }

    public String toString() {
        return "BladeTenantInterceptor(super=" + super.toString() + ", tenantLineHandler=" + getTenantLineHandler() + ", tenantProperties=" + getTenantProperties() + ", adminTenantTables=" + getAdminTenantTables() + ")";
    }

    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        }
        if (o instanceof BladeTenantInterceptor) {
            BladeTenantInterceptor other = (BladeTenantInterceptor) o;
            if (other.canEqual(this) && super.equals(o)) {
                Object this$tenantLineHandler = getTenantLineHandler();
                Object other$tenantLineHandler = other.getTenantLineHandler();
                if (this$tenantLineHandler == null) {
                    if (other$tenantLineHandler != null) {
                        return false;
                    }
                } else if (!this$tenantLineHandler.equals(other$tenantLineHandler)) {
                    return false;
                }
                Object this$tenantProperties = getTenantProperties();
                Object other$tenantProperties = other.getTenantProperties();
                if (this$tenantProperties == null) {
                    if (other$tenantProperties != null) {
                        return false;
                    }
                } else if (!this$tenantProperties.equals(other$tenantProperties)) {
                    return false;
                }
                Object this$adminTenantTables = getAdminTenantTables();
                Object other$adminTenantTables = other.getAdminTenantTables();
                return this$adminTenantTables == null ? other$adminTenantTables == null : this$adminTenantTables.equals(other$adminTenantTables);
            }
            return false;
        }
        return false;
    }

    protected boolean canEqual(final Object other) {
        return other instanceof BladeTenantInterceptor;
    }

    public int hashCode() {
        int result = super.hashCode();
        Object $tenantLineHandler = getTenantLineHandler();
        int result2 = (result * 59) + ($tenantLineHandler == null ? 43 : $tenantLineHandler.hashCode());
        Object $tenantProperties = getTenantProperties();
        int result3 = (result2 * 59) + ($tenantProperties == null ? 43 : $tenantProperties.hashCode());
        Object $adminTenantTables = getAdminTenantTables();
        return (result3 * 59) + ($adminTenantTables == null ? 43 : $adminTenantTables.hashCode());
    }

    public TenantLineHandler getTenantLineHandler() {
        return this.tenantLineHandler;
    }

    public BladeTenantProperties getTenantProperties() {
        return this.tenantProperties;
    }

    public List<String> getAdminTenantTables() {
        return this.adminTenantTables;
    }

    public void setTenantLineHandler(TenantLineHandler tenantLineHandler) {
        super.setTenantLineHandler(tenantLineHandler);
        this.tenantLineHandler = tenantLineHandler;
    }

    protected void processInsert(Insert insert, int index, String sql, Object obj) {
    	if (!this.tenantProperties.getEnhance().booleanValue()) {
    	      super.processInsert(insert, index, sql, obj);
    	      return;
    	    } 
    	    if (this.tenantLineHandler.ignoreTable(insert.getTable().getName()))
    	      return; 
    	    List<Column> columns = insert.getColumns();
    	    if (CollectionUtils.isEmpty(columns))
    	      return; 
    	    String tenantIdColumn = this.tenantLineHandler.getTenantIdColumn();
    	    if (columns.stream().map(Column::getColumnName).anyMatch(i -> i.equals(tenantIdColumn)))
    	      return; 
    	    columns.add(new Column(tenantIdColumn));
    	    List<Expression> duplicateUpdateColumns = insert.getDuplicateUpdateExpressionList();
    	    if (CollectionUtils.isNotEmpty(duplicateUpdateColumns)) {
    	      EqualsTo equalsTo = new EqualsTo();
    	      equalsTo.setLeftExpression((Expression)new StringValue(tenantIdColumn));
    	      equalsTo.setRightExpression(this.tenantLineHandler.getTenantId());
    	      duplicateUpdateColumns.add(equalsTo);
    	    } 
    	    Select select = insert.getSelect();
    	    if (select != null) {
    	      processInsertSelect(select.getSelectBody());
    	    } else if (insert.getItemsList() != null) {
    	      ItemsList itemsList = insert.getItemsList();
    	      if (itemsList instanceof MultiExpressionList) {
    	        ((MultiExpressionList)itemsList).getExpressionLists().forEach(el -> el.getExpressions().add(this.tenantLineHandler.getTenantId()));
    	      } else {
    	        ((ExpressionList)itemsList).getExpressions().add(this.tenantLineHandler.getTenantId());
    	      } 
    	    } else {
    	      throw ExceptionUtils.mpe("Failed to process multiple-table update, please exclude the tableName or statementId", new Object[0]);
    	    } 
    }

    protected void processPlainSelect(PlainSelect plainSelect) {
        List<SelectItem> selectItems = plainSelect.getSelectItems();
        if (CollectionUtils.isNotEmpty(selectItems)) {
            selectItems.forEach(this::processSelectItem);
        }
        Expression where = plainSelect.getWhere();
        processWhereSubSelect(where);
        FromItem fromItem = plainSelect.getFromItem();
        List<Table> list = processFromItem(fromItem);
        List<Table> mainTables = new ArrayList<>(list);
        List<Join> joins = plainSelect.getJoins();
        if (CollectionUtils.isNotEmpty(joins)) {
            mainTables = processJoins(mainTables, joins);
        }
        if (CollectionUtils.isNotEmpty(mainTables) && !doTenantFilters(mainTables)) {
            plainSelect.setWhere(builderExpression(where, mainTables));
        }
    }

    protected void processUpdate(Update update, int index, String sql, Object obj) {
        Table table = update.getTable();
        if (this.tenantLineHandler.ignoreTable(table.getName()) || doTenantFilter(table.getName())) {
            return;
        }
        update.setWhere(andExpression(table, update.getWhere()));
    }

    protected void processDelete(Delete delete, int index, String sql, Object obj) {
        Table table = delete.getTable();
        if (this.tenantLineHandler.ignoreTable(table.getName()) || doTenantFilter(table.getName())) {
            return;
        }
        delete.setWhere(andExpression(table, delete.getWhere()));
    }

    protected BinaryExpression andExpression(Table table, Expression where) {
    	EqualsTo equalsTo = new EqualsTo();
    	Expression aliasColumn = getAliasColumn(table);
        //Column tenantId = this.tenantLineHandler.getTenantId();
        // Column extends ASTNodeAccessImpl implements Expression
        Expression tenantId = this.tenantLineHandler.getTenantId();
        if (doTenantFilter(table.getName())) {
        	Expression stringValue = new StringValue("1");
            tenantId = stringValue;
            aliasColumn = stringValue;
        }
        equalsTo.setLeftExpression(aliasColumn);
        equalsTo.setRightExpression(tenantId);
        if (null != where) {
            if (where instanceof OrExpression) {
                return new AndExpression(equalsTo, new Parenthesis(where));
            }
            return new AndExpression(equalsTo, where);
        }
        return equalsTo;

    }

    protected Expression builderExpression(Expression currentExpression, List<Table> tables) {
        if (CollectionUtils.isEmpty(tables)) {
            return currentExpression;
        }
        Expression tenantId = this.tenantLineHandler.getTenantId();
        List<EqualsTo> equalsTos = (List) tables.stream().filter(x -> {
            return !this.tenantLineHandler.ignoreTable(x.getName());
        }).filter(x2 -> {
            return !doTenantFilter(x2.getName());
        }).map(item -> {
            return new EqualsTo(getAliasColumn(item), tenantId);
        }).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(equalsTos)) {
            return currentExpression;
        }
        Expression injectExpression = (Expression) equalsTos.get(0);
        if (equalsTos.size() > 1) {
            for (int i = 1; i < equalsTos.size(); i++) {
                injectExpression = new AndExpression(injectExpression, (Expression) equalsTos.get(i));
            }
        }
        if (currentExpression == null) {
            return injectExpression;
        }
        if (currentExpression instanceof OrExpression) {
            return new AndExpression(new Parenthesis(currentExpression), injectExpression);
        }
        return new AndExpression(currentExpression, injectExpression);
    }

    private List<Table> processFromItem(FromItem fromItem) {
        while (fromItem instanceof ParenthesisFromItem) {
            fromItem = ((ParenthesisFromItem) fromItem).getFromItem();
        }
        List<Table> mainTables = new ArrayList<>();
        if (fromItem instanceof Table) {
            Table fromTable = (Table) fromItem;
            mainTables.add(fromTable);
        } else if (fromItem instanceof SubJoin) {
            List<Table> tables = processSubJoin((SubJoin) fromItem);
            mainTables.addAll(tables);
        } else {
            processOtherFromItem(fromItem);
        }
        return mainTables;
    }

    private List<Table> processSubJoin(SubJoin subJoin) {
        List<Table> mainTables = new ArrayList<>();
        if (subJoin.getJoinList() != null) {
            List<Table> list = processFromItem(subJoin.getLeft());
            mainTables.addAll(list);
            mainTables = processJoins(mainTables, subJoin.getJoinList());
        }
        return mainTables;
    }

    private List<Table> processJoins(List<Table> mainTables, List<Join> joins) {
        Table mainTable = null;
        Table leftTable = null;
        if (mainTables == null) {
            mainTables = new ArrayList<>();
        } else if (mainTables.size() == 1) {
            mainTable = mainTables.get(0);
            leftTable = mainTable;
        }
        Deque<List<Table>> onTableDeque = new LinkedList<>();
        for (Join join : joins) {
            FromItem joinItem = join.getRightItem();
            List<Table> joinTables = null;
            if (joinItem instanceof Table) {
                joinTables = new ArrayList<>();
                joinTables.add((Table) joinItem);
            } else if (joinItem instanceof SubJoin) {
                joinTables = processSubJoin((SubJoin) joinItem);
            }
            if (joinTables != null) {
                if (join.isSimple()) {
                    mainTables.addAll(joinTables);
                } else {
                    Table joinTable = joinTables.get(0);
                    List<Table> onTables = null;
                    if (join.isRight()) {
                        mainTable = joinTable;
                        if (leftTable != null) {
                            onTables = Collections.singletonList(leftTable);
                        }
                    } else if (join.isLeft()) {
                        onTables = Collections.singletonList(joinTable);
                    } else if (join.isInner()) {
                        onTables = mainTable == null ? Collections.singletonList(joinTable) : Arrays.asList(mainTable, joinTable);
                        mainTable = null;
                    }
                    mainTables = new ArrayList<>();
                    if (mainTable != null) {
                        mainTables.add(mainTable);
                    }
                    Collection<Expression> originOnExpressions = join.getOnExpressions();
                    if (originOnExpressions.size() == 1 && onTables != null) {
                        List<Expression> onExpressions = new LinkedList<>();
                        onExpressions.add(builderExpression(originOnExpressions.iterator().next(), onTables));
                        join.setOnExpressions(onExpressions);
                        leftTable = joinTable;
                    } else {
                        onTableDeque.push(onTables);
                        if (originOnExpressions.size() > 1) {
                            Collection<Expression> onExpressions2 = new LinkedList<>();
                            for (Expression originOnExpression : originOnExpressions) {
                                List<Table> currentTableList = onTableDeque.poll();
                                if (CollectionUtils.isEmpty(currentTableList)) {
                                    onExpressions2.add(originOnExpression);
                                } else {
                                    onExpressions2.add(builderExpression(originOnExpression, currentTableList));
                                }
                            }
                            join.setOnExpressions(onExpressions2);
                        }
                        leftTable = joinTable;
                    }
                }
            } else {
                processOtherFromItem(joinItem);
                leftTable = null;
            }
        }
        return mainTables;
    }

    public boolean doTenantFilter(String tableName) {
        return AuthUtil.isAdministrator() && !this.adminTenantTables.contains(tableName);
    }

    public boolean doTenantFilters(List<Table> tables) {
        List<String> tableNames = (List) tables.stream().map((v0) -> {
            return v0.getName();
        }).collect(Collectors.toList());
        return AuthUtil.isAdministrator() && !CollectionUtil.containsAny(this.adminTenantTables, tableNames);
    }
}