import { DictVspApi } from '../../../../api/dict-vsp';
import { FormsSheetApi } from '../../../../api/form_sheet';
import { FormsApi } from '../../../../api/forms';
import { SspApi } from '../../../../api/ssp';
import { TasksApi } from '../../../../api/tasks';
import { UsersApi } from '../../../../api/users';
import { DIRECTION_TRANSLATE, FORM_TYPE_TRANSLATE, ROLES_ID_RUSSIAN_NAME, SHEET_NAME, STAGE_ROLE_RUSSIAN_NAME } from '../../../../constants/constants';

export const VALUE_TRANSFORMERS = {
  Роль: transformRole,
  'Старая роль': transformRole,
  'Новая роль': transformRole,
  Пользователь: transformUser,
  'Региональный филиал': transformSsp,
  'Список СПП/РФ': transformSsps,
  'Создана для СПП/РФ': transformSspsDict,
  'Лист': transformSheet,
  'СПП/РФ': transformSsp,
  'Статья расходов': transformExpense,
  'Информация о задаче': transformForm,
  'Направление': transformDirection,
  'Для роли': transformRoleChanges,
  'Колонки в этапе': transformColumns,
  'Форма': transformFormType,
  'ВСП': transformVSP,
};

export function transformRole(value) {
  return ROLES_ID_RUSSIAN_NAME[value] || 'Роль не найдена';
}
export function transformFormType(value) {
  return FORM_TYPE_TRANSLATE[value] || 'Форма не найдена';
}

export function transformRoleChanges(value) {
  if (typeof value === 'string') {
    return STAGE_ROLE_RUSSIAN_NAME[value]
  }
  return {
    before: STAGE_ROLE_RUSSIAN_NAME[value.before],
    after: STAGE_ROLE_RUSSIAN_NAME[value.after],
  }
}

export async function transformUser(userId) {
  try {
    const user = await UsersApi.getById(userId);
    if (user && user.full_name) {
      return {
        ФИО: user.full_name,
        Почта: user.email || '—',
      };
    }
    return 'Пользователь не найден';
  } catch (error) {
    return 'Пользователь не найден';
  }
}

export async function transformSsp(sspId) {
  try {
    const ssp = await SspApi.getSsp(sspId);
    if (ssp?.result?.title) {
      return ssp.result.title;
    }
    return 'РФ/ССП не найден';
  } catch (error) {
    return 'РФ/ССП не найден';
  }
}

export async function transformSsps(sspIds) {
  if (!Array.isArray(sspIds) || sspIds.length === 0) {
    return [];
  }

  const res = [];
  for (const sspId of sspIds) {
    try {
      const ssp = await SspApi.getSsp(sspId);
      res.push(ssp?.result?.title || 'РФ/ССП не найден');
    } catch (error) {
      res.push('РФ/ССП не найден');
    }
  }
  return res;
}

export async function transformSspsDict(ssps) {
  if (!Array.isArray(ssps) || ssps.length === 0) {
    return [];
  }

  const res = [];
  for (const ssp of ssps) {
    try {
      res.push(ssp?.title || 'РФ/ССП не найден');
    } catch (error) {
      res.push('РФ/ССП не найден');
    }
  }
  return res;
}

export function transformSheet(value) {
  return SHEET_NAME[value] || 'Лист не найден';
}

export async function transformExpense(itemId) {
  if (!itemId) {
    return 'нет информации'
  }
  const res = await FormsSheetApi.getExpenseItem(itemId);
  const expense = res.result;
  return expense.name;
}

export async function transformForm(formId) {
  if (!formId) {
    return 'нет информации'
  }
  const res = await FormsApi.getForm(formId);
  const form = res.result;
  const formInfo = {
    'название': FORM_TYPE_TRANSLATE[form.form_type_code],
    'ССП/РФ': form.org_unit.title,
    'Год': form.year,
  }
  return formInfo
}

export function transformDirection(direction) {
  if (!direction) {
    return '-';
  }
  return DIRECTION_TRANSLATE[direction];
}

export async function transformColumns(cols, formId, sheet) {
  if (!formId || !sheet) return cols;
  const res = await FormsApi.getForm(formId);
  const form = res.result;
  const formType = form.form_type_code;

  const { config } = await import(`../../../../components/RealtimeTable/constants/${formType}/${sheet}.js`);
  const columns = config.config.columns;
  function findColumnAndHeaders(columns, targetAccessorKey) {

    // Рекурсивная функция для поиска колонки и сбора родителей
    function searchRecursively(columnsArray, path = []) {
      for (let column of columnsArray) {
        // Проверяем текущую колонку
        if (column.accessorKey === targetAccessorKey) {
          // Нашли целевую колонку, возвращаем путь с заголовками
          return {
            found: true,
            headers: [...path, column.header],
            column: column
          };
        }

        // Если у колонки есть вложенные колонки, ищем в них
        if (column.columns && Array.isArray(column.columns)) {
          const result = searchRecursively(column.columns, [...path, column.header]);
          if (result.found) {
            return result;
          }
        }
      }

      return { found: false };
    }

    const result = searchRecursively(columns);

    if (result.found) {
      return {
        headers: result.headers,
        column: result.column,
        path: result.headers.join(' → ')
      };
    } else {
      return {
        headers: [],
        column: null,
        path: null,
        error: `Колонка с accessorKey "${targetAccessorKey}" не найдена`
      };
    }
  }
  if (Array.isArray(cols)) {
    const res = [];
    cols.forEach(c => {
      res.push(findColumnAndHeaders(columns, "data." + c).path || '');
    })
    return res;
  }

  const translateColsAfter = [];
  const translateColsBefore = [];

  cols.after.forEach(c => {
    translateColsAfter.push(findColumnAndHeaders(columns, "data." + c).path || '');
  })
  cols.before.forEach(c => {
    translateColsBefore.push(findColumnAndHeaders(columns, "data." + c).path || '');
  })

  // Пример использования:
  return { after: translateColsAfter, before: translateColsBefore };
}

export async function transformVSP(vspId) {
  console.log(vspId);

  if (!vspId) {
    return 'нет id';
  }
  const res = await DictVspApi.getById(vspId);
  if (!res.success) {
    return 'нет информации'
  }
  const vsp = res.result;
  return vsp.system_code + ' ' + vsp.registration_number;
}