import { isFileBlob, type FileBlob } from "./Data";
import type { RoleDefinition } from "./Roles";

export interface FolderData {
  folderNumber: string;
  name: string;
  deedType: string;
  description: string;
  archived_description: string;
  status: string;
  created_at: string;
  updated_at: string;
  customers: string[];
  documents: FileBlob[];
  motes: string[];
  stakeholders: string[];
}

export function isFolderData(data: any): data is FolderData {
  if (typeof data !== 'object' || data === null) return false;

  const requiredStringFields = [
    'folderNumber',
    'name',
    'deedType',
    'description',
    'archived_description',
    'status',
    'created_at',
    'updated_at'
  ];

  for (const field of requiredStringFields) {
    if (typeof data[field] !== 'string') return false;
  }

  const requiredArrayFields = [
    'customers',
    'motes',
    'stakeholders'
  ];

  for (const field of requiredArrayFields) {
    if (!Array.isArray(data[field]) || !data[field].every((item: any) => typeof item === 'string')) {
      return false;
    }
  }

  const requiredFileBlobArrayFields = [
    'documents',
  ];

  for (const field of requiredFileBlobArrayFields) {
    if (!Array.isArray(data[field])) return false;
    if (data[field].length > 0 && !data[field].every(isFileBlob)) return false;
  }

  return true;
}

const emptyFolderData: FolderData = {
  folderNumber: '',
  name: '',
  deedType: '',
  description: '',
  archived_description: '',
  status: '',
  created_at: '',
  updated_at: '',
  customers: [],
  documents: [],
  motes: [],
  stakeholders: []
};

const folderDataFields: string[] = Object.keys(emptyFolderData);

const FolderPublicFields: string[] = [];

// All the attributes are private in that case
export const FolderPrivateFields = [
  ...folderDataFields.filter(key => !FolderPublicFields.includes(key))
];

export interface FolderCreated {
  processId: string,
  process: any, // Process
  folderData: FolderData,
}

export function setDefaultFolderRoles(ownerId: string, stakeholdersId: string[], customersId: string[]): Record<string, RoleDefinition> {
  return {
    demiurge: {
      members: [ownerId],
      validation_rules: [],
      storages: []
    },
    owner: {
      members: [ownerId],
      validation_rules: [
        {
          quorum: 0.5,
          fields: [...folderDataFields, 'roles'],
          min_sig_member: 1,
        },
      ],
      storages: []
    },
    stakeholders: {
      members: stakeholdersId,
      validation_rules: [
        {
          quorum: 0.5,
          fields: ['documents', 'motes'],
          min_sig_member: 1,
        },
      ],
      storages: []
    },
    customers: {
      members: customersId,
      validation_rules: [
        {
          quorum: 0.0,
          fields: folderDataFields,
          min_sig_member: 0.0,
        },
      ],
      storages: []
    },
    apophis: {
      members: [ownerId],
      validation_rules: [],
      storages: []
    }
  }
};