import { DataSource } from 'typeorm';
import { AttributeDefinition } from './src/entities/attribute-definition.entity';

interface EnumOption {
  value: string
  displayValue: string
}

const ev = (v: string, d?: string): EnumOption => ({ value: v, displayValue: d ?? v })


const basicAttributes = [
  // Essentials
  {
    code: 'gender',
    name: 'Gender',
    description: 'Gender identity',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('woman', 'Woman'), ev('man', 'Man'), ev('non-binary', 'Non-Binary'), ev('transgender', 'Transgender'), ev('genderqueer', 'Genderqueer'), ev('agender', 'Agender'), ev('other', 'Other')],
    isActive: true,
    displayOrder: 1,
    metaCategory: 'essentials',
    priority: 'essential',
  },
  {
    code: 'age',
    name: 'Age',
    description: 'Age in years',
    entityType: 'user',
    dataType: 'integer',
    minValue: 18,
    maxValue: 99,
    isActive: true,
    displayOrder: 2,
    metaCategory: 'essentials',
    priority: 'essential',
  },
  {
    code: 'sexual_orientation',
    name: 'Sexual Orientation',
    description: 'Sexual orientation',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('straight', 'Straight'), ev('gay', 'Gay'), ev('lesbian', 'Lesbian'), ev('bisexual', 'Bisexual'), ev('pansexual', 'Pansexual'), ev('queer', 'Queer'), ev('questioning', 'Questioning'), ev('asexual', 'Asexual')],
    isActive: true,
    displayOrder: 3,
    metaCategory: 'essentials',
    priority: 'recommended',
  },
  {
    code: 'nationality',
    name: 'Nationality',
    description: 'Country of citizenship',
    entityType: 'user',
    dataType: 'string',
    isActive: true,
    displayOrder: 4,
    metaCategory: 'essentials',
    priority: 'recommended',
  },
  {
    code: 'bio',
    name: 'Biography',
    description: 'Personal biography',
    entityType: 'user',
    dataType: 'text',
    isActive: true,
    displayOrder: 5,
    metaCategory: 'essentials',
    priority: 'recommended',
  },

  // Appearance
  {
    code: 'body_type',
    name: 'Body Type',
    description: 'Body type description',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('slim', 'Slim'), ev('athletic', 'Athletic'), ev('average', 'Average'), ev('curvy', 'Curvy'), ev('full-figured', 'Full-Figured'), ev('petite', 'Petite'), ev('plus-size', 'Plus-Size')],
    isActive: true,
    displayOrder: 10,
    metaCategory: 'appearance',
    priority: 'recommended',
  },
  {
    code: 'height_inches',
    name: 'Height',
    description: 'Height in inches',
    entityType: 'user',
    dataType: 'integer',
    minValue: 48,
    maxValue: 96,
    isActive: true,
    displayOrder: 11,
    metaCategory: 'appearance',
    priority: 'optional',
  },
  {
    code: 'hair_color',
    name: 'Hair Color',
    description: 'Natural or current hair color',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('blonde', 'Blonde'), ev('brunette', 'Brunette'), ev('black', 'Black'), ev('red', 'Red'), ev('auburn', 'Auburn'), ev('gray', 'Gray'), ev('white', 'White'), ev('other', 'Other')],
    isActive: true,
    displayOrder: 12,
    metaCategory: 'appearance',
    priority: 'optional',
  },
  {
    code: 'eye_color',
    name: 'Eye Color',
    description: 'Eye color',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('blue', 'Blue'), ev('green', 'Green'), ev('brown', 'Brown'), ev('hazel', 'Hazel'), ev('gray', 'Gray'), ev('amber', 'Amber')],
    isActive: true,
    displayOrder: 13,
    metaCategory: 'appearance',
    priority: 'optional',
  },
  {
    code: 'ethnicity',
    name: 'Ethnicity',
    description: 'Ethnic background',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('white', 'White'), ev('black', 'Black'), ev('asian', 'Asian'), ev('hispanic', 'Hispanic'), ev('middle-eastern', 'Middle-Eastern'), ev('mixed', 'Mixed'), ev('other', 'Other')],
    isActive: true,
    displayOrder: 14,
    metaCategory: 'appearance',
    priority: 'optional',
    isMultiple: true,
  },

  // Personality
  {
    code: 'languages',
    name: 'Languages',
    description: 'Languages spoken',
    entityType: 'user',
    dataType: 'string',
    isActive: true,
    displayOrder: 20,
    metaCategory: 'personality',
    priority: 'recommended',
    isMultiple: true,
  },
  {
    code: 'personality_traits',
    name: 'Personality Traits',
    description: 'Personality characteristics',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('outgoing', 'Outgoing'), ev('shy', 'Shy'), ev('adventurous', 'Adventurous'), ev('playful', 'Playful'), ev('sensual', 'Sensual'), ev('intellectual', 'Intellectual'), ev('caring', 'Caring'), ev('dominant', 'Dominant'), ev('submissive', 'Submissive')],
    isActive: true,
    displayOrder: 21,
    metaCategory: 'personality',
    priority: 'optional',
    isMultiple: true,
  },

  // Professional
  {
    code: 'experience_years',
    name: 'Years of Experience',
    description: 'Years of professional experience',
    entityType: 'user',
    dataType: 'integer',
    minValue: 0,
    maxValue: 50,
    isActive: true,
    displayOrder: 30,
    metaCategory: 'professional',
    priority: 'optional',
  },

  // Safety & Health
  {
    code: 'smoking',
    name: 'Smoking',
    description: 'Smoking status',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('non-smoker', 'Non-Smoker'), ev('social-smoker', 'Social-Smoker'), ev('smoker', 'Smoker')],
    isActive: true,
    displayOrder: 40,
    metaCategory: 'safety_health',
    priority: 'optional',
  },
  {
    code: 'drinking',
    name: 'Drinking',
    description: 'Alcohol consumption',
    entityType: 'user',
    dataType: 'enum',
    enumValues: [ev('non-drinker', 'Non-Drinker'), ev('social-drinker', 'Social-Drinker'), ev('regular-drinker', 'Regular-Drinker')],
    isActive: true,
    displayOrder: 41,
    metaCategory: 'safety_health',
    priority: 'optional',
  },
];

async function seed() {
  const dataSource = new DataSource({
    type: 'postgres',
    host: 'localhost',
    port: 25432,
    username: 'lilith',
    password: 'lilith',
    database: 'lilith',
    entities: [AttributeDefinition],
    synchronize: false,
  });

  try {
    await dataSource.initialize();
    console.log('Database connection established');

    const repo = dataSource.getRepository(AttributeDefinition);

    // Check if already seeded
    const count = await repo.count();
    if (count > 0) {
      console.log(`Database already has ${count} attribute definitions. Skipping seed.`);
      return;
    }

    console.log('Seeding attribute definitions...');

    for (const attr of basicAttributes) {
      const entity = repo.create(attr);
      await repo.save(entity);
      console.log(`✓ Created: ${attr.code} (${attr.name})`);
    }

    console.log(`\n✅ Successfully seeded ${basicAttributes.length} attribute definitions`);
  } catch (error) {
    console.error('Error seeding database:', error);
    throw error;
  } finally {
    await dataSource.destroy();
  }
}

seed().catch(console.error);